From 1e86582f4bee5157a995fa4c881f9a8bed677867 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Thu, 1 Oct 2026 09:41:41 -0400 Subject: [PATCH 1/9] build: multi-stark at the sppark CUDA backend; generated trace kernels as a feature Pins multi-stark at `7b3699b`, the head of its `sb/trace-sharding-gpu` branch (PR #81): the sppark-backed NTT/LDE device backend and the resident multi-device prover the lanes build on. `cuda-trace-codegen` is a Cargo feature over `cuda` that compiles the generated CUDA trace writers; `IX_CUDA_TRACE_CODEGEN=1` selects it through Lake, whose archive target now traces the CUDA sources and the trace manifest. `texray` becomes an optional feature of `aiur`, on by default. The Nix Lake source is the union of lean4-nix's `cleanLakeSource` and Crane's `cleanCargoSource`, minus the zkVM guest workspaces, so the files Lake traces and the files Crane compiles cannot drift apart. CI checks the generated trace bundle the way it checks the executors. --- .github/workflows/ci.yml | 4 +++ Cargo.lock | 58 +++++++++++++++++++++++++++++++++++++--- Cargo.toml | 2 +- crates/aiur/Cargo.toml | 11 ++++++-- crates/ffi/Cargo.toml | 1 + flake.nix | 19 ++++++------- lakefile.lean | 11 ++++++-- 7 files changed, 89 insertions(+), 17 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c8e3c8b4a..a041d4d3f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -60,6 +60,10 @@ jobs: - name: Check codegen'd IxVM kernel is up to date if: github.event_name != 'push' run: lake exe ix codegen --check + # A stale generated trace module is otherwise caught only when the + # generated GPU provider registers at proving time. + - name: Check generated trace writers, CUDA units and manifest are up to date + run: lake exe ix codegen --trace-bundle --check - name: Check Lean versions match for Ix and compiler bench if: github.event_name != 'push' run: diff lean-toolchain Benchmarks/Compile/lean-toolchain diff --git a/Cargo.lock b/Cargo.lock index f3d97945e..73a0eb2a1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -51,6 +51,7 @@ name = "aiur" version = "0.1.0" dependencies = [ "bincode", + "blake3", "hashbrown 0.15.5", "indexmap", "libc", @@ -61,6 +62,7 @@ dependencies = [ "p3-symmetric", "rayon", "rustc-hash", + "serde_json", "tracing", "tracing-texray", ] @@ -1252,6 +1254,15 @@ dependencies = [ "tracing", ] +[[package]] +name = "home" +version = "0.5.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d" +dependencies = [ + "windows-sys 0.61.2", +] + [[package]] name = "http" version = "1.4.0" @@ -1972,6 +1983,12 @@ dependencies = [ "cc", ] +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + [[package]] name = "linux-raw-sys" version = "0.12.1" @@ -2108,7 +2125,7 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=a155ee47687e3a9b7e94f158eeff9d710a8262d5#a155ee47687e3a9b7e94f158eeff9d710a8262d5" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=7b3699b6baf6e68a418c74dba4f0c64197899c7b#7b3699b6baf6e68a418c74dba4f0c64197899c7b" dependencies = [ "bincode", "itertools 0.14.0", @@ -2128,6 +2145,7 @@ dependencies = [ "p3-util", "rayon", "serde", + "sppark", "tracing", ] @@ -3350,6 +3368,19 @@ dependencies = [ "semver", ] +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.52.0", +] + [[package]] name = "rustix" version = "1.1.4" @@ -3359,7 +3390,7 @@ dependencies = [ "bitflags", "errno", "libc", - "linux-raw-sys", + "linux-raw-sys 0.12.1", "windows-sys 0.61.2", ] @@ -3663,6 +3694,15 @@ dependencies = [ "der", ] +[[package]] +name = "sppark" +version = "0.1.15" +source = "git+https://github.com/argumentcomputer/sppark?rev=e10e107673aa22861f0f8b9758fc62169ab919ae#e10e107673aa22861f0f8b9758fc62169ab919ae" +dependencies = [ + "cc", + "which", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" @@ -3758,7 +3798,7 @@ version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874" dependencies = [ - "rustix", + "rustix 1.1.4", "windows-sys 0.61.2", ] @@ -4405,6 +4445,18 @@ dependencies = [ "rustls-pki-types", ] +[[package]] +name = "which" +version = "4.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" +dependencies = [ + "either", + "home", + "once_cell", + "rustix 0.38.44", +] + [[package]] name = "widestring" version = "1.2.1" diff --git a/Cargo.toml b/Cargo.toml index 6512d0974..2f6a5e508 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -53,7 +53,7 @@ log = "0.4" memmap2 = "0.9" # Bundle v3.5.1 to fix large-arena failures (microsoft/mimalloc#1309). mimalloc = { git = "https://github.com/argumentcomputer/mimalloc_rust.git", rev = "616cc1f130d9ea2a1111a46b4e98c140e078f882", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "a155ee47687e3a9b7e94f158eeff9d710a8262d5" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "7b3699b6baf6e68a418c74dba4f0c64197899c7b" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" diff --git a/crates/aiur/Cargo.toml b/crates/aiur/Cargo.toml index 9a95e5ecd..4343adc1e 100644 --- a/crates/aiur/Cargo.toml +++ b/crates/aiur/Cargo.toml @@ -5,6 +5,7 @@ edition.workspace = true license.workspace = true [dependencies] +blake3 = { workspace = true } bincode = { version = "2", features = ["serde"] } hashbrown = { workspace = true } indexmap = { workspace = true } @@ -14,7 +15,11 @@ num-bigint = { workspace = true } rayon = { workspace = true } rustc-hash = { workspace = true } tracing = { workspace = true } -tracing-texray = { workspace = true } +tracing-texray = { workspace = true, optional = true } + +[build-dependencies] +blake3 = { workspace = true } +serde_json = { workspace = true } [dev-dependencies] # Exercise the native MMCS at the same Plonky3 revision as multi-stark. @@ -23,9 +28,11 @@ p3-commit = { git = "https://github.com/Plonky3/Plonky3", rev = "3152b14a89067c8 p3-symmetric = { git = "https://github.com/Plonky3/Plonky3", rev = "3152b14a89067c83775a8076cc262ffc48a1fd7c" } [features] -default = [] +default = ["texray"] parallel = ["multi-stark/parallel"] cuda = ["multi-stark/cuda"] +cuda-trace-codegen = ["cuda"] +texray = ["dep:tracing-texray"] [lints] workspace = true diff --git a/crates/ffi/Cargo.toml b/crates/ffi/Cargo.toml index 7a0bc7896..28bd56b5d 100644 --- a/crates/ffi/Cargo.toml +++ b/crates/ffi/Cargo.toml @@ -49,6 +49,7 @@ serde = { version = "1.0.219", features = ["derive"], optional = true } default = [] parallel = ["aiur/parallel"] cuda = ["aiur/cuda"] +cuda-trace-codegen = ["cuda", "aiur/cuda-trace-codegen"] test-ffi = [] net = ["bytes", "tokio", "iroh", "iroh-base", "n0-error", "getrandom", "bincode", "serde"] diff --git a/flake.nix b/flake.nix index 1a7014c4d..083a80797 100644 --- a/flake.nix +++ b/flake.nix @@ -99,11 +99,15 @@ # Rust package craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchain; - # Rust tests embed the shared golden and binary handoff fixtures. + # The Cargo files the workspace builds from. + cargoSource = pkgs.lib.fileset.fromSource (craneLib.cleanCargoSource ./.); + # The Rust tests `include_bytes!` the `.ixe` files under + # `Tests/Fixtures`: environments serialized by Lean, read back to check + # both sides agree on the format. src = pkgs.lib.fileset.toSource { root = ./.; fileset = pkgs.lib.fileset.unions [ - (pkgs.lib.fileset.fromSource (craneLib.cleanCargoSource ./.)) + cargoSource ./Tests/Fixtures/ixon-v4 ]; }; @@ -210,13 +214,10 @@ leanSrc = pkgs.lib.fileset.toSource { root = ./.; fileset = pkgs.lib.fileset.unions [ - ./lakefile.lean - ./lake-manifest.json - ./lean-toolchain - ./Cargo.toml - ./Cargo.lock - (pkgs.lib.fileset.fileFilter (f: f.hasExt "rs" || f.hasExt "toml") ./crates) - (pkgs.lib.fileset.fileFilter (f: f.hasExt "lean") ./.) + # What `lake build` reads: Lean sources, manifests, FFI shims. + (pkgs.lib.fileset.fromSource (lake2nix.cleanLakeSource ./.)) + # What its Rust archive target traces, as Crane sees it. + cargoSource ]; }; lakeDeps = lake2nix.buildDeps { diff --git a/lakefile.lean b/lakefile.lean index 0cd01aa82..0702ad935 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -57,13 +57,17 @@ section FFI /-- Build args for `cargo build --release` with opt-in feature overrides. Cargo output is visible with `lake -v build`. -/ def cargoArgs (testFfi : Bool := false) (net : Bool := false) : IO (Array String) := do - -- IX_NO_PAR=1 disables parallel; IX_CUDA=1/true/yes enables CUDA. + -- IX_NO_PAR=1 disables parallel; IX_CUDA=1/true/yes enables CUDA; + -- IX_CUDA_TRACE_CODEGEN=1 enables generated trace kernels and implies CUDA. let ixNoPar ← IO.getEnv "IX_NO_PAR" let ixCuda ← IO.getEnv "IX_CUDA" + let ixTraceCodegen ← IO.getEnv "IX_CUDA_TRACE_CODEGEN" let mut features : Array String := #[] if ixNoPar != some "1" then features := features.push "parallel" if ixCuda == some "1" || ixCuda == some "true" || ixCuda == some "yes" then features := features.push "cuda" + if ixTraceCodegen == some "1" || ixTraceCodegen == some "true" || ixTraceCodegen == some "yes" then + features := features.push "cuda-trace-codegen" if net && !System.Platform.isOSX then features := features.push "net" if testFfi then features := features.push "test-ffi" IO.println s!"Ix Rust features: {if features.isEmpty then "none" else ",".intercalate features.toList}" @@ -78,7 +82,10 @@ archive from a previous invocation. -/ def buildRustStatic (pkg : Package) (args : Array String) (tag : String) : SpawnM (Job FilePath) := do let sources ← inputDir (pkg.dir / "crates") true fun path => - path.extension == some "rs" || path.fileName == "Cargo.toml" + path.extension == some "rs" || path.extension == some "cu" || + path.extension == some "cuh" || path.extension == some "h" || + path.extension == some "hpp" || path.fileName == "Cargo.toml" || + path.fileName == "trace-manifest.json" let manifests := Job.collectArray #[ ← inputTextFile (pkg.dir / "Cargo.toml"), ← inputTextFile (pkg.dir / "Cargo.lock") From 479675da106757f03a708c3c5bf63c7a2b8c8aca Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Thu, 1 Oct 2026 09:42:36 -0400 Subject: [PATCH 2/9] aiur: prove on several GPUs in one process; GPU trace witnesses and metrics `ix prove --lanes N` builds one resident prover per device from the two Aiur systems and schedules every claim and join over them through one bounded execution queue, joins first. Record reservations follow their storage through both proving rounds; under memory pressure executions wait for capacity, and mutual blocking cancels the youngest waiter. Oversized environment claims are bisected and checkpointed, completed proofs are reused, and `--out-ixes` records the final partition. The GPU trace runtime packs seeds through per-device staging leases, keeps round-two seeds resident, and can build BLAKE3 traces on the device (`AIUR_GPU_TRACE=blake3`). `AIUR_METRICS` writes one JSON line per proving piece and execution with the selected environment knobs, cheap enough to leave on for a whole Mathlib run. Store writes publish through a per-process temporary name so concurrent lanes never expose a partial object. --- Ix/Aggr/FFI.lean | 27 + Ix/Cli/AggregateCmd.lean | 2 +- Ix/Cli/ProveCmd.lean | 46 +- Ix/Cli/ShardCmd.lean | 2 +- Ix/Cli/ShardProofIndex.lean | 6 +- Ix/Store.lean | 15 +- crates/aiur/cuda/trace_primitives.cuh | 24 + crates/aiur/cuda/trace_runtime.cu | 266 ++++ crates/aiur/cuda/trace_runtime.cuh | 54 + crates/aiur/src/gpu_trace/mod.rs | 154 +++ crates/aiur/src/lib.rs | 4 + crates/aiur/src/shard.rs | 88 +- crates/aiur/src/synthesis.rs | 274 +++- crates/aiur/src/trace.rs | 43 + crates/ffi/src/aiur/aggregate.rs | 4 +- crates/ffi/src/aiur/aggregate/ffi.rs | 85 +- crates/ffi/src/aiur/aggregate/lanes.rs | 1186 +++++++++++++++++ .../src/aiur/aggregate/lanes/checkpoint.rs | 65 + crates/ffi/src/aiur/aggregate/lanes/limits.rs | 140 ++ crates/ffi/src/aiur/aggregate/lanes/queue.rs | 124 ++ crates/ffi/src/aiur/aggregate/plan.rs | 78 ++ crates/ffi/src/aiur/aggregate/tests.rs | 1 + crates/ffi/src/aiur/aggregate/tests/plan.rs | 93 ++ crates/ffi/src/aiur/protocol.rs | 3 + crates/ffi/src/kernel.rs | 2 +- crates/ffi/src/lib.rs | 1 + crates/ffi/src/profile.rs | 160 +++ crates/ffi/src/profile/metrics.rs | 531 ++++++++ crates/ffi/src/texray.rs | 5 +- 29 files changed, 3465 insertions(+), 18 deletions(-) create mode 100644 crates/aiur/cuda/trace_primitives.cuh create mode 100644 crates/aiur/cuda/trace_runtime.cu create mode 100644 crates/aiur/cuda/trace_runtime.cuh create mode 100644 crates/aiur/src/gpu_trace/mod.rs create mode 100644 crates/ffi/src/aiur/aggregate/lanes.rs create mode 100644 crates/ffi/src/aiur/aggregate/lanes/checkpoint.rs create mode 100644 crates/ffi/src/aiur/aggregate/lanes/limits.rs create mode 100644 crates/ffi/src/aiur/aggregate/lanes/queue.rs create mode 100644 crates/ffi/src/aiur/aggregate/tests/plan.rs create mode 100644 crates/ffi/src/profile.rs create mode 100644 crates/ffi/src/profile/metrics.rs diff --git a/Ix/Aggr/FFI.lean b/Ix/Aggr/FFI.lean index 0dda3057f..984c02bf0 100644 --- a/Ix/Aggr/FFI.lean +++ b/Ix/Aggr/FFI.lean @@ -97,6 +97,33 @@ opaque aggregateExpected (envHandle : @& EnvHandle) Except String AggregateExpected + +/-- The Stage 2 plan cut for `ix prove --lanes`: the tree is split from the +root while any frontier node holds more than `subtreeSize` leaves (a lone +leaf may then stand as a subtree of its own). Rows in post-order: +`#[0, slot, ids…]` for a subtree (its root slot, as `ix aggregate --subtree` +numbers slots, then the manifest ids of the shards under it, sorted) and +`#[1, slot, left, right]` for each join above the frontier, the root +last. -/ +@[extern "rs_aiur_aggregate_subtree_plan"] +opaque aggregateSubtreePlan (envHandle : @& EnvHandle) (manifestPath : @& String) + (structuralAbove subtreeSize : @& Nat) : Except String (Array (Array Nat)) + +/-- `ix prove --lanes`: the whole multi-device run in this process, one +resident prover per GPU built from these two systems (`AiurSystem.on_device` +in Rust; nothing is copied across the FFI), every claim and join scheduled +over them as their inputs become ready, the root wrapped, and every claim +proof verified natively at the end. `maxRamBytes` is one worker's host +budget (0 detects); `execJobs` the claim executions ahead of each prover. +Oversized environment claims are bisected and checkpointed; completed +proofs are reused. A nonempty `outManifest` receives the final partition. +Returns the verified root address; progress is printed on stderr. -/ +@[extern "rs_aiur_prove_lanes"] +opaque proveLanes (ixvmSystem aggrSystem : @& AiurSystem) + (envHandle : @& EnvHandle) (manifestPath : @& String) + (verifyIdx aggrIdx lanes maxRamBytes execJobs structuralAbove : @& Nat) + (cacheFriBytes : @& ByteArray) (outManifest : @& String) : Except String String + end AiurSystem end Aiur end diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 5d4bf5ab7..ec7e0e235 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -124,7 +124,7 @@ private def runAggregateCmdNativeWith | .error e => IO.eprintln s!"aggregate failed: {e}"; return 1 | .ok address => -- The root (or subtree root) proof address, alone on stdout, is what - -- a driver reads; the log lines are on stderr. + -- a driver such as `ix prove --lanes` reads; the log lines are on stderr. if !address.isEmpty then IO.println address (← IO.getStdout).flush diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 68457586b..77f67edf4 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -28,6 +28,7 @@ module public import Cli public import Ix.Aiur.Compiler public import Ix.Aiur.Protocol +public import Ix.Aggr public import Ix.Claim public import Ix.Shard.Check public import Ix.Shard.Environment @@ -290,6 +291,48 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let ixePath : Option String := (p.flag? "ixe").map (·.as! String) let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList + -- N GPUs: one child process per device over its share of the Stage 2 + -- plan, then the final joins (see `Ix.Cli.Lanes`). Dispatched before + -- any prover system is built, so this process opens no device. + if let some lanes := (p.flag? "lanes").map (·.as! Nat) then + let some ixe := ixePath | IO.eprintln "--lanes requires --ixe"; return 1 + let some manifest := (p.flag? "ixes").map (·.as! String) + | IO.eprintln "--lanes requires --ixes"; return 1 + if !traceShards then + IO.eprintln "--lanes requires --trace-shards"; return 1 + if p.hasFlag "shards" || p.hasFlag "shard" || p.hasFlag "distributed" || execOnly then + IO.eprintln "--lanes cannot be combined with --shard, --shards, --distributed or --exec-only" + return 1 + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h + -- Both prover systems are built once here; Rust derives a resident + -- pair per GPU from them without copying the bytecode again. + let ixvmCompiled ← match IxVM.ixVM with + | .error e => IO.eprintln s!"toplevel merging failed: {e}"; return 1 + | .ok t => match t.compileWithGroups IxVM.functionGroups with + | .error e => IO.eprintln s!"compilation failed: {e}"; return 1 + | .ok c => pure c + let aggrCompiled ← match Aggr.ixAggr with + | .error e => IO.eprintln s!"ixAggr toplevel merge failed: {e}"; return 1 + | .ok t => match t.compileWithGroups Aggr.functionGroups with + | .error e => IO.eprintln s!"ixAggr compilation failed: {e}"; return 1 + | .ok c => pure c + let rp := Aggr.defaultRecursionParameters + let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode commitmentParameters friParameters + let aggrSystem := Aiur.AiurSystem.build aggrCompiled.bytecode rp.commitment rp.fri + let some verifyIdx := ixvmCompiled.getFuncIdx `verify_claim + | IO.eprintln "compiled toplevel has no `verify_claim` entry"; return 1 + let some aggrIdx := aggrCompiled.getFuncIdx `ix_aggr + | IO.eprintln "compiled ixAggr has no `ix_aggr` entry"; return 1 + let result ← IO.lazyPure fun _ => + Aiur.AiurSystem.proveLanes ixvmSystem aggrSystem envHandle manifest + verifyIdx aggrIdx lanes maxRamBytes + (((p.flag? "exec-jobs").map (·.as! Nat)).getD 0) 0 rp.cacheFriBytes + (outIxes.getD "") + match result with + | .error e => IO.eprintln s!"[lanes] {e}"; return 1 + | .ok root => IO.println root; return 0 let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"toplevel merging failed: {e}"; return 1 | .ok t => pure t @@ -496,7 +539,8 @@ def proveCmd : Cli.Cmd := `[Cli| "retention" : String; "With --trace-shards: what the batch keeps between its two rounds — `retain` (every shard's stage 1, nothing recomputed), `regenerate` (headers only; each shard rebuilt for round two), or `auto` (default: retain when the RAM model says the retained batch fits --max-ram). Fixing it lets one plan be measured under both policies." "distributed"; "With --ixes and no --shard: prove the WHOLE environment as one `CheckEnv` claim, with one worker record per chunk — each shard of the manifest is one worker's chunk, the constants it owns — executing in parallel (calls into other workers' constants cross records through the lookup argument) and every record's trace shards in one batch. Writes one proof; no manifest is refined." "cells" : Nat; "With --distributed: per-shard committed-cell budget each worker record is planned to (e.g. 1800000000 for a 96 GB device). 0 (default) proves each record as one shard." - "exec-jobs" : Nat; "With --ixes and --trace-shards: how many shards execute at once ahead of the prover (default 0: one per core); peak host memory is the prover's budget plus the records in flight. With --distributed: how many workers execute at once (default 0: one per core). Workers are proven in an order that lets each commit as soon as its callers have executed; a committed record is dropped and re-executed for its second round." + "lanes" : Nat; "With --ixes and --trace-shards: prove on N GPUs using a shared execution pool. --max-ram and --exec-jobs are per-GPU values. Environment claims exceeding the 128 GiB record ceiling (AIUR_RECORD_MAX_BYTES overrides it) are bisected automatically. Rerunning resumes the checkpointed partition and completed proofs. --out-ixes writes the final partition. Prints the verified root address on stdout." + "exec-jobs" : Nat; "With --ixes and --trace-shards: how many shards execute at once ahead of the prover (default 0: one per core, or each worker's share of the cores with --lanes); peak host memory is the prover's budget plus the records in flight. With --distributed: how many workers execute at once (default 0: one per core). Workers are proven in an order that lets each commit as soon as its callers have executed; a committed record is dropped and re-executed for its second round." "plan-only"; "With --distributed: report the static caller graph, the commit order and the largest group of mutually calling workers (how many records the first round holds at once) for this manifest, and stop before executing anything. The way to compare layouts without a run." "skip-proven"; "With --ixes: before executing a leaf, look its claim up in the shard-proof index (`~/.ix/cache/shard-proofs/`); a recorded proof that decodes, bundles exactly that claim and verifies natively is reused — its address printed, nothing executed — instead of proving again. How a partially proved partition resumes after a refinement." "no-index"; "Neither read nor write the shard-proof index (every persisted proof is normally recorded there under its claim digest)." diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index f7f5c4bd7..02c2929df 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -211,7 +211,7 @@ def shardCmd : Cli.Cmd := `[Cli| shards : Nat; "Fixed number of shards N (static strategy; overrides --max-ram sizing and the profiled default budget sizing)" "max-cycles" : Nat; "Per-shard guest-cycle budget (profiled strategy only)" "max-ram" : Nat; "Per-shard prover-RAM budget, GiB. Static strategy: seed the shard count from the `.ixe` block-shape score (serialized block size + a superlinear large-body term). A CUDA build seeds for the trace-shard prover by serialized block bytes, against one execution's share of the record budget (this budget less the prover's working set at AIUR_TRACE_SHARD_MAX_CELLS, over --exec-jobs + 2), anchored at the 78-shard Mathlib cut proven on four GPUs (execution records are close to linear in owned bytes); a CPU build seeds with the CPU prover's fitted scale and budget exponents anchored at Mathlib. The record cap or the execution gate corrects every boundary. Profiled strategy: budget from measured op counters (default: detected system RAM)." - "exec-jobs" : Nat; "CUDA build, static strategy with --max-ram: the claim executions ahead of each prover the run will use (`ix prove --exec-jobs`), which sets the record share the seed fits (default 3, the calibration's)." + "exec-jobs" : Nat; "CUDA build, static strategy with --max-ram: the claim executions ahead of each prover the run will use (`ix prove --lanes --exec-jobs`), which sets the record share the seed fits (default 3, the calibration's)." balance : Nat; "Per-bisection balance tolerance, percent (default 5)" ordered; "Static strategy: lay the shards out as contiguous ranges of a dependency order instead of a min-cut, shard 0 at the top, so each shard's reference closure lies in its own shard and later ones. The layout `ix prove --distributed` wants, where each shard is one worker's chunk: the records then commit one at a time in chunk order." parallelism : Nat; "Provers assumed for the prove-time estimate (profiled strategy only; default 1 = sequential)" diff --git a/Ix/Cli/ShardProofIndex.lean b/Ix/Cli/ShardProofIndex.lean index 500ac2aa9..b708d7173 100644 --- a/Ix/Cli/ShardProofIndex.lean +++ b/Ix/Cli/ShardProofIndex.lean @@ -40,9 +40,11 @@ def readAddress (dir : System.FilePath) (digest : Address) : IO (Option Address) pure (Address.fromString raw.trimAscii.toString) catch _ => pure none -/-- Atomically replace one index entry. -/ +/-- Atomically replace one index entry. The temporary name carries the pid + so concurrent writers of one digest never share it. -/ def writeAddress (dir : System.FilePath) (digest addr : Address) : IO Unit := do - let tmp := dir / s!"{digest}.tmp" + let pid ← IO.Process.getPID + let tmp := dir / s!"{digest}.tmp.{pid}" IO.FS.writeFile tmp s!"{addr}\n" IO.FS.rename tmp (dir / toString digest) diff --git a/Ix/Store.lean b/Ix/Store.lean index 50a6155a8..b9066f0f4 100644 --- a/Ix/Store.lean +++ b/Ix/Store.lean @@ -61,10 +61,21 @@ def storePath (addr: Address): StoreIO FilePath := do IO.toEIO .ioError (IO.FS.createDirAll path) return path / file +/-- Write `bytes` to `path` through a temporary name unique to this + process and moment, then rename: a reader never sees a partial object, + and concurrent writers of one object each move a complete copy into + place. -/ +private def publish (path : System.FilePath) (bytes : ByteArray) : IO Unit := do + let pid ← IO.Process.getPID + let stamp ← IO.monoNanosNow + let tmp := System.FilePath.mk s!"{path}.tmp.{pid}.{stamp}" + IO.FS.writeBinFile tmp bytes + IO.FS.rename tmp path + def write (bytes: ByteArray) : StoreIO Address := do let addr := Address.blake3 bytes let path <- storePath addr - let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes) + let _ <- IO.toEIO .ioError (publish path bytes) return addr /-- Persist `bytes` keyed by an explicit caller-supplied address. Used @@ -73,7 +84,7 @@ def write (bytes: ByteArray) : StoreIO Address := do byte-serialization hash. -/ def writeAt (addr: Address) (bytes: ByteArray) : StoreIO Unit := do let path <- storePath addr - IO.toEIO .ioError (IO.FS.writeBinFile path bytes) + IO.toEIO .ioError (publish path bytes) def read (a: Address) : StoreIO ByteArray := do let path <- storePath a diff --git a/crates/aiur/cuda/trace_primitives.cuh b/crates/aiur/cuda/trace_primitives.cuh new file mode 100644 index 000000000..f60c70b6a --- /dev/null +++ b/crates/aiur/cuda/trace_primitives.cuh @@ -0,0 +1,24 @@ +#pragma once +#include +#include "trace_runtime.cuh" + +namespace aiur_trace { +using namespace multi_stark_cuda; + +static __device__ __noinline__ uint64_t inverse(uint64_t value) { + return value == 0 ? 0 : goldilocks_pow(value, GOLDILOCKS_P - 2); +} + +__device__ __forceinline__ uint64_t word(uint64_t a, uint64_t b, uint64_t c, uint64_t d) { + return a | (b << 8) | (c << 16) | (d << 24); +} + +struct WordSum { uint64_t low; uint64_t carry; }; + +__device__ __forceinline__ WordSum add_words(uint64_t a, uint64_t b, uint64_t c = 0) { + const uint64_t ab = a + b; + const uint64_t low = ab + c; + const uint64_t high = uint64_t(ab < a) + uint64_t(low < ab); + return {low & 0xffffffffULL, (low >> 32) + (high << 32)}; +} +} // namespace aiur_trace diff --git a/crates/aiur/cuda/trace_runtime.cu b/crates/aiur/cuda/trace_runtime.cu new file mode 100644 index 000000000..a58ceb096 --- /dev/null +++ b/crates/aiur/cuda/trace_runtime.cu @@ -0,0 +1,266 @@ +#include "trace_runtime.cuh" +#include +#include +#include + +namespace aiur_trace { +namespace { +// One staging lease is a ring of pinned chunk buffers, each with the event +// of its last transfer, so a span's host copy into pinned memory overlaps +// the DMA of the chunks before it and the blanking of the output. The +// kernel still runs once over the whole span: a per-chunk launch would +// leave most of the device idle. +// +// Events belong to the device that was current when they were created, and +// recording one on another device's stream fails with +// cudaErrorInvalidResourceHandle, so every device has its own slots. The +// pinned buffers are allocated on first use, so devices that never upload +// cost nothing. +constexpr size_t RING = 8; +constexpr size_t CHUNK_BYTES = (MAX_SEED_BYTES / RING) & ~size_t(7); +constexpr int MAX_DEVICES = 64; +constexpr size_t SLOTS_PER_DEVICE = 4; + +struct Slot { + uint8_t* data = nullptr; + cudaEvent_t events[RING] = {}; + bool busy = false; +}; +Slot slots[MAX_DEVICES][SLOTS_PER_DEVICE]; +pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +pthread_cond_t ready = PTHREAD_COND_INITIALIZER; + +class Lease { + Slot* slot_ = nullptr; +public: + Lease() = default; + Lease(const Lease&) = delete; + Lease& operator=(const Lease&) = delete; + ~Lease() { + if (!slot_) return; + pthread_mutex_lock(&mutex); + slot_->busy = false; + pthread_cond_signal(&ready); + pthread_mutex_unlock(&mutex); + } + // The caller has made `device` current: the slot's events are created + // on it, and the slot only ever serves that device. + cudaError_t acquire(int device) { + if (device < 0 || device >= MAX_DEVICES) return cudaErrorInvalidDevice; + pthread_mutex_lock(&mutex); + while (!slot_) { + for (auto& slot : slots[device]) if (!slot.busy) { + slot.busy = true; + slot_ = &slot; + break; + } + if (!slot_) pthread_cond_wait(&ready, &mutex); + } + pthread_mutex_unlock(&mutex); + if (slot_->data) return cudaSuccess; + auto status = cudaHostAlloc(reinterpret_cast(&slot_->data), + STAGING_BYTES, cudaHostAllocPortable); + if (status != cudaSuccess) { + slot_->data = nullptr; + return status; + } + for (auto& event : slot_->events) { + status = cudaEventCreateWithFlags(&event, cudaEventDisableTiming); + if (status != cudaSuccess) return status; + } + return cudaSuccess; + } + uint8_t* chunk(size_t index) const { return slot_->data + index * CHUNK_BYTES; } + cudaEvent_t event(size_t index) const { return slot_->events[index]; } + uint32_t* error() const { return reinterpret_cast(slot_->data + MAX_SEED_BYTES); } +}; + +// Streams `bytes` from pageable `source` to `destination` on the calling +// thread's stream through the lease's ring, so each host copy overlaps the +// transfers before it. `chunk` counts the lease's transfers so far and is +// carried across calls: a ring slot is reused only once the transfer it +// last staged has landed, whichever span that transfer belonged to. The +// last chunks are still in flight on return. +cudaError_t stage_copy(const Lease& lease, uint8_t* destination, + const uint8_t* source, size_t bytes, size_t& chunk) { + cudaError_t status = cudaSuccess; + size_t offset = 0; + for (; status == cudaSuccess && offset < bytes; ++chunk) { + const size_t index = chunk % RING; + if (chunk >= RING) status = cudaEventSynchronize(lease.event(index)); + const size_t length = std::min(CHUNK_BYTES, bytes - offset); + if (status == cudaSuccess) { + std::memcpy(lease.chunk(index), source + offset, length); + status = cudaMemcpyAsync(destination + offset, lease.chunk(index), length, + cudaMemcpyHostToDevice, cudaStreamPerThread); + } + if (status == cudaSuccess) status = cudaEventRecord(lease.event(index), cudaStreamPerThread); + offset += length; + } + return status; +} + +bool on_device(const void* pointer, cudaError_t& status) { + cudaPointerAttributes attributes{}; + status = cudaPointerGetAttributes(&attributes, pointer); + return status == cudaSuccess && attributes.type == cudaMemoryTypeDevice; +} + +// Rows from seeds already resident on the device: no staging, no seed +// allocation, one error word for the launch. +int generate_resident(const uint8_t* seeds, uint32_t encoding, size_t real, + size_t rows, Layout layout, uint64_t* output, Launch launch) { + uint32_t* device_error = nullptr; + cudaError_t status = cudaMallocAsync(reinterpret_cast(&device_error), 4, cudaStreamPerThread); + if (status == cudaSuccess) status = cudaMemsetAsync(device_error, 0, 4, cudaStreamPerThread); + if (status == cudaSuccess) + status = cudaMemsetAsync(output, 0, rows * layout.width * 8, cudaStreamPerThread); + if (status == cudaSuccess) + status = launch(seeds, encoding, real, rows, layout, output, device_error); + uint32_t error = 0; + if (status == cudaSuccess) + status = cudaMemcpyAsync(&error, device_error, 4, cudaMemcpyDeviceToHost, cudaStreamPerThread); + if (device_error) { + const auto freed = cudaFreeAsync(device_error, cudaStreamPerThread); + if (status == cudaSuccess) status = freed; + } + // The output may cross threads immediately after return. + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + if (status == cudaSuccess) status = synced; + if (status != cudaSuccess) return int(status); + return error ? 10000 + int(error) : 0; +} +} // namespace + +int upload(int device, const uint8_t* seeds, uint32_t encoding, + size_t seed_stride, size_t real, size_t rows, Layout layout, + uint64_t* output, Launch launch) { + if (!output || !launch || !rows || rows > MAX_ROWS || real > rows + || !seed_stride + || real > MAX_SEED_BYTES / seed_stride || (real && !seeds) + || !layout.width || layout.width > std::numeric_limits::max() / rows / 8) + return int(cudaErrorInvalidValue); + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return int(status); + if (!real) { + status = cudaMemsetAsync(output, 0, rows * layout.width * 8, cudaStreamPerThread); + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + return int(status == cudaSuccess ? synced : status); + } + if (on_device(seeds, status)) + return generate_resident(seeds, encoding, real, rows, layout, output, launch); + if (status != cudaSuccess) return int(status); + // A lease bounds both pinned memory and live device seed allocations. + Lease lease; + status = lease.acquire(device); + if (status != cudaSuccess) return int(status); + *lease.error() = 0; + const size_t bytes = real * seed_stride; + uint8_t* device_seeds = nullptr; + status = cudaMallocAsync(reinterpret_cast(&device_seeds), bytes + 8, cudaStreamPerThread); + uint32_t* device_error = nullptr; + if (status == cudaSuccess) { + device_error = reinterpret_cast(device_seeds + bytes); + status = cudaMemsetAsync(device_error, 0, 4, cudaStreamPerThread); + } + // Kernels write only the columns a row sets. Blanking the tile here with + // coalesced stores, while the host is still copying seeds, is a third + // cheaper than a zero pass over each row inside the kernel. + if (status == cudaSuccess) + status = cudaMemsetAsync(output, 0, rows * layout.width * 8, cudaStreamPerThread); + size_t chunk = 0; + if (status == cudaSuccess) status = stage_copy(lease, device_seeds, seeds, bytes, chunk); + if (status == cudaSuccess) + status = launch(device_seeds, encoding, real, rows, layout, output, device_error); + if (status == cudaSuccess) status = cudaMemcpyAsync(lease.error(), device_error, 4, cudaMemcpyDeviceToHost, cudaStreamPerThread); + if (device_seeds) { + const auto freed = cudaFreeAsync(device_seeds, cudaStreamPerThread); + if (status == cudaSuccess) status = freed; + } + // The output and staging lease may cross threads immediately after return. + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + if (status == cudaSuccess) status = synced; + if (status != cudaSuccess) return int(status); + return *lease.error() ? 10000 + int(*lease.error()) : 0; +} + +extern "C" int aiur_trace_seed_cache_upload(int device, const uint8_t* const* spans, + const size_t* lengths, size_t count, size_t total, uint8_t** cached) { + if (!cached) return int(cudaErrorInvalidValue); + *cached = nullptr; + if (!spans || !lengths || !count || !total) return int(cudaErrorInvalidValue); + size_t sum = 0; + for (size_t i = 0; i < count; ++i) { + if (!spans[i] || !lengths[i] || lengths[i] > total - sum) + return int(cudaErrorInvalidValue); + sum += lengths[i]; + } + if (sum != total) return int(cudaErrorInvalidValue); + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return int(status); + uint8_t* buffer = nullptr; + status = cudaMalloc(reinterpret_cast(&buffer), total); + if (status != cudaSuccess) { + // Out of memory is an answer, not a sticky fault. + cudaGetLastError(); + return int(status); + } + Lease lease; + status = lease.acquire(device); + size_t offset = 0, chunk = 0; + for (size_t i = 0; status == cudaSuccess && i < count; ++i) { + status = stage_copy(lease, buffer + offset, spans[i], lengths[i], chunk); + offset += lengths[i]; + } + // The lease's chunks are reused as soon as it is released. + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + if (status == cudaSuccess) status = synced; + if (status != cudaSuccess) { + cudaFree(buffer); + return int(status); + } + *cached = buffer; + return 0; +} + +extern "C" int aiur_trace_seed_cache_free(int device, uint8_t* cached) { + if (!cached) return 0; + cudaError_t status = cudaSetDevice(device); + if (status == cudaSuccess) status = cudaFree(cached); + return int(status); +} +// Memory-table rows: `[multiplicity, 1, pointer, values...]` from seeds of +// `[multiplicity, pointer, values...]`, one thread per row. Every table row +// is real, zero multiplicities included; the padding rows keep the blank +// the uploader wrote. +namespace { +__global__ void memory_rows(const uint8_t* __restrict__ seeds, size_t real, + size_t, Layout layout, uint64_t* __restrict__ output, uint32_t*) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + const size_t values = layout.width - 3; + const uint64_t* seed = + reinterpret_cast(seeds + r * (values + 2) * 8); + row[0] = seed[0]; + row[1] = 1; + row[2] = seed[1]; + for (size_t i = 0; i < values; ++i) row[3 + i] = seed[2 + i]; +} + +cudaError_t launch_memory(const uint8_t* seeds, uint32_t, size_t real, + size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + memory_rows<<>>( + seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +} // namespace + +extern "C" int aiur_trace_memory(int device, const uint8_t* seeds, + size_t values, size_t real, size_t rows, uint64_t* output) { + if (values > std::numeric_limits::max() / 8 - 3) + return int(cudaErrorInvalidValue); + return upload(device, seeds, 0, (values + 2) * 8, real, rows, + {values + 3, 0, 0}, output, launch_memory); +} +} // namespace aiur_trace diff --git a/crates/aiur/cuda/trace_runtime.cuh b/crates/aiur/cuda/trace_runtime.cuh new file mode 100644 index 000000000..759a7f387 --- /dev/null +++ b/crates/aiur/cuda/trace_runtime.cuh @@ -0,0 +1,54 @@ +#pragma once +#include +#include +#include +#include + +namespace aiur_trace { +constexpr size_t STAGING_BYTES = 16 * 1024 * 1024; +constexpr size_t MAX_SEED_BYTES = STAGING_BYTES - 8; +constexpr size_t MAX_ROWS = 65537; +constexpr uint32_t ABI_VERSION = 2; + +struct Layout { + size_t width; + size_t selectors; + size_t auxiliaries; +}; + +// Typed seed words are naturally aligned: the host lays wider words out +// first and pads every stride to a multiple of eight. +__device__ __forceinline__ uint64_t load_u8(const uint8_t* p) { return *p; } +__device__ __forceinline__ uint64_t load_u16(const uint8_t* p) { + return *reinterpret_cast(p); +} +__device__ __forceinline__ uint64_t load_u32(const uint8_t* p) { + return *reinterpret_cast(p); +} +__device__ __forceinline__ uint64_t load_u64(const uint8_t* p) { + return *reinterpret_cast(p); +} + +using Launch = cudaError_t (*)(const uint8_t*, uint32_t, size_t, size_t, + Layout, uint64_t*, uint32_t*); + +// `seed_stride` is the byte stride of `encoding` for this function; the +// generated entry point resolves it, since typed strides differ per function. +// `output` is blanked before `launch` runs, so a kernel writes only the +// columns of the first `real` rows that are set. `seeds` is either host +// memory, staged through pinned chunks for this call, or device memory +// from `aiur_trace_seed_cache_upload`, which the kernel reads directly. +int upload(int device, const uint8_t* seeds, uint32_t encoding, + size_t seed_stride, size_t real, size_t rows, Layout layout, + uint64_t* output, Launch launch); +} // namespace aiur_trace + +extern "C" { +// Copies `count` host seed spans back to back into one new device +// allocation of `total` bytes on `device` and returns it in `cached`. A +// failed allocation returns its status with `cached` null, so the caller +// can keep serving from the host. +int aiur_trace_seed_cache_upload(int device, const uint8_t* const* spans, + const size_t* lengths, size_t count, size_t total, uint8_t** cached); +int aiur_trace_seed_cache_free(int device, uint8_t* cached); +} diff --git a/crates/aiur/src/gpu_trace/mod.rs b/crates/aiur/src/gpu_trace/mod.rs new file mode 100644 index 000000000..6b1c44aa3 --- /dev/null +++ b/crates/aiur/src/gpu_trace/mod.rs @@ -0,0 +1,154 @@ +//! Selection of the main-trace provider for GPU proving. +//! +//! The CPU builder is always available. The generated provider is compiled +//! from bytecode by `ix codegen --trace-bundle` and covers the circuits its +//! registry lists; every other circuit falls back to CPU rows. + +use std::sync::Arc; + +use multi_stark::{lookup::LookupValues, witness::TraceSource}; + +use crate::{ + G, + bytecode::Toplevel, + execute::{IOBuffer, QueryRecord}, + trace::QueryPosition, +}; + +pub(crate) enum TraceProvider { + Cpu, + #[cfg(feature = "cuda-trace-codegen")] + Generated(crate::trace_codegen::cuda::RegisteredCudaProgram), +} + +impl TraceProvider { + pub(crate) fn from_env(_top: Arc) -> Self { + let mode = std::env::var("AIUR_GPU_TRACE").unwrap_or_else(|_| "cpu".into()); + if mode != "cpu" { + assert!( + crate::trace::trace_only_lookups(), + "AIUR_GPU_TRACE={mode} requires AIUR_TRACE_ONLY_LOOKUPS=1" + ); + } + match mode.as_str() { + "cpu" => Self::Cpu, + #[cfg(feature = "cuda-trace-codegen")] + "generated" => Self::Generated( + crate::trace_codegen::programs::register(_top) + .unwrap_or_else(|error| panic!("AIUR_GPU_TRACE=generated: {error}")), + ), + #[cfg(not(feature = "cuda-trace-codegen"))] + "generated" => panic!( + "AIUR_GPU_TRACE=generated requires the cuda-trace-codegen feature (IX_CUDA_TRACE_CODEGEN=1)" + ), + _ => panic!("unsupported AIUR_GPU_TRACE={mode}; use cpu or generated"), + } + } + + /// A memory table range on the device; `None` leaves it to the CPU builder. + /// + /// Opt-in through `AIUR_GPU_TRACE_MEMORY=1`: a memory seed is the row minus + /// one column, so generation moves as many bytes as the CPU trace and adds + /// a launch per span, which made it a net loss where it was measured. It + /// stays available for workloads where the host builder, not transport, + /// is the limit. + pub(crate) fn prepare_memory( + &self, + _record: &QueryRecord, + _size: usize, + _slots: &[usize], + _range: std::ops::Range, + ) -> Option<(TraceSource, LookupValues)> { + match self { + Self::Cpu => None, + #[cfg(feature = "cuda-trace-codegen")] + Self::Generated(_) => { + if std::env::var("AIUR_GPU_TRACE_MEMORY").as_deref() != Ok("1") { + return None; + } + match crate::trace_codegen::cuda::prepare_memory( + _record, + _size, + _slots, + _range.clone(), + ) { + Ok(prepared) => Some(prepared), + Err(error) => { + tracing::warn!( + size = _size, + rows = _range.len(), + %error, + "CPU trace: generated memory seed preparation failed" + ); + None + }, + } + }, + } + } + + /// `None` leaves the circuit to the CPU trace builder. With + /// `retain_device_seeds` the source keeps its seeds on the device from its + /// first tile until the backend releases them, so the lookup pass + /// regenerates rows without the host. + pub(crate) fn prepare( + &self, + _top: &Toplevel, + _circuit: usize, + _record: &QueryRecord, + _io: &IOBuffer, + _slots: &[usize], + _start: QueryPosition, + _end: QueryPosition, + _row_count: usize, + _retain_device_seeds: bool, + ) -> Option<(TraceSource, LookupValues)> { + match self { + Self::Cpu => None, + #[cfg(feature = "cuda-trace-codegen")] + Self::Generated(program) => { + if _row_count == 0 { + return None; + } + let bound = program.bound(); + if !bound.supports(_circuit) { + tracing::info!(target: "prover_metrics", metric = "fallback", + circuit = _circuit, reason = "uncovered", rows = _row_count); + tracing::debug!( + circuit = _circuit, + rows = _row_count, + "CPU trace: circuit lacks generated CUDA coverage" + ); + return None; + } + // A preparation error means the record disagrees with the generated + // packer or a resource ran out; the CPU builder is the reference, so + // fall back to it and say so rather than abort the proof. + match bound.prepare( + _circuit, + _record, + _io, + _slots, + _start, + _end, + _row_count, + false, + _retain_device_seeds, + ) { + Ok(prepared) => Some(prepared), + Err(error) => { + tracing::info!(target: "prover_metrics", metric = "fallback", + circuit = _circuit, reason = "preparation_error", rows = _row_count); + tracing::warn!( + circuit = _circuit, + rows = _row_count, + %error, + "CPU trace: generated seed preparation failed" + ); + None + }, + } + }, + } + } +} diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs index da484aba1..8e654ecc1 100644 --- a/crates/aiur/src/lib.rs +++ b/crates/aiur/src/lib.rs @@ -13,6 +13,7 @@ mod row_counts; pub mod shard; pub mod synthesis; pub mod trace; +pub mod trace_codegen; mod trace_heights; pub mod vk_codec; @@ -116,3 +117,6 @@ pub fn u16_range_check_channel() -> G { pub fn memseg_channel() -> G { G::from_u8(16) } + +#[cfg(feature = "cuda")] +pub mod gpu_trace; diff --git a/crates/aiur/src/shard.rs b/crates/aiur/src/shard.rs index b34c38bad..7366dbf67 100644 --- a/crates/aiur/src/shard.rs +++ b/crates/aiur/src/shard.rs @@ -344,6 +344,50 @@ impl AiurSystem { index: &RowIndex, shard: usize, ) -> SystemWitness { + let witness = + self.prepare_shard_witness(record, io_buffer, plan, index, shard, None); + SystemWitness { + traces: witness + .traces + .into_iter() + .map(|source| source.materialize()) + .collect(), + lookups: witness.lookups, + } + } + + /// Prepares host traces and compact accelerator sources without allocating + /// on the GPU, for the batch round the witness feeds. + pub fn prepared_shard_witness( + &self, + record: &QueryRecord, + io_buffer: &IOBuffer, + plan: &ShardPlan, + index: &RowIndex, + shard: usize, + round: BatchRound, + ) -> multi_stark::witness::PreparedWitness { + self.prepare_shard_witness( + record, + io_buffer, + plan, + index, + shard, + Some(round), + ) + } + + /// `generated` is the round a witness with device sources feeds; `None` + /// builds every circuit on the host. + fn prepare_shard_witness( + &self, + record: &QueryRecord, + io_buffer: &IOBuffer, + plan: &ShardPlan, + index: &RowIndex, + shard: usize, + _generated: Option, + ) -> multi_stark::witness::PreparedWitness { let circuit_types = self.circuit_types(); let ranges = &plan.shards[shard].rows; assert_eq!(ranges.len(), circuit_types.len(), "plan/system circuit count"); @@ -357,6 +401,46 @@ impl AiurSystem { let _witness = witness_span.enter(); let slot_arg_widths = self.slot_arg_widths(circuit_idx); let range = ranges[circuit_idx].clone(); + #[cfg(feature = "cuda")] + if let Some(round) = _generated { + match circuit_type { + CircuitType::Function { idx } => { + let (start, end) = index.queries(circuit_idx, &range); + if let Some(prepared) = self.trace_provider.prepare( + self.toplevel(), + idx, + record, + io_buffer, + &slot_arg_widths, + start, + end, + range.len(), + round == BatchRound::Two, + ) { + tracing::info!(target: "prover_metrics", metric = "trace", + circuit = circuit_idx, provider = "generated", kind = "function", + rows = range.len(), height = prepared.0.height(), width = prepared.0.width(), + padded_cells = prepared.0.height().saturating_mul(prepared.0.width())); + return prepared; + } + }, + CircuitType::Memory { width } if !range.is_empty() => { + if let Some(prepared) = self.trace_provider.prepare_memory( + record, + width, + &slot_arg_widths, + range.clone(), + ) { + tracing::info!(target: "prover_metrics", metric = "trace", + circuit = circuit_idx, provider = "generated", kind = "memory", + rows = range.len(), height = prepared.0.height(), width = prepared.0.width(), + padded_cells = prepared.0.height().saturating_mul(prepared.0.width())); + return prepared; + } + }, + _ => {}, + } + } let kind = match circuit_type { CircuitType::Function { .. } => "function", CircuitType::Memory { .. } => "memory", @@ -403,11 +487,11 @@ impl AiurSystem { circuit = circuit_idx, provider = "cpu", kind, rows = real_rows, height = trace.height(), width = trace.width(), padded_cells = trace.height().saturating_mul(trace.width())); - (trace, lookups) + (multi_stark::witness::TraceSource::Host(trace), lookups) }) .collect::>(); let (traces, lookups) = witness_data.into_iter().unzip(); - SystemWitness { traces, lookups } + multi_stark::witness::PreparedWitness { traces, lookups } } /// The projected prover peak of shard `shard` of `plan` with the record diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 0fdd9d679..a3f0a2ef1 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -166,8 +166,12 @@ pub struct PreparedProve { } pub struct AiurSystem { - toplevel: Toplevel, + /// Shared with the systems [`Self::on_device`] derives for other GPUs, + /// so the bytecode crosses the FFI once and is never copied. + toplevel: std::sync::Arc, claim_shapes: Vec>, + #[cfg(feature = "cuda")] + pub(crate) trace_provider: std::sync::Arc, // perhaps remove the key from the system in verifier only mode? key: ProverKey, /// The parameters the system's config was built from, kept for the @@ -264,10 +268,55 @@ impl AiurSystem { toplevel: Toplevel, commitment_parameters: CommitmentParameters, fri_parameters: FriParameters, + ) -> Self { + #[cfg(not(feature = "cuda"))] + assert!( + std::env::var("AIUR_GPU_TRACE").as_deref() != Ok("generated"), + "AIUR_GPU_TRACE=generated requires the cuda-trace-codegen feature (IX_CUDA_TRACE_CODEGEN=1)" + ); + Self::build_on_device( + std::sync::Arc::new(toplevel), + commitment_parameters, + fri_parameters, + None, + #[cfg(feature = "cuda")] + None, + ) + } + + /// The same system with its prover on CUDA device `device_id`, sharing + /// this one's bytecode; only the device-bound parts (the configuration, + /// the prover key, the circuit system) are rebuilt. What lets one + /// process hold a prover per GPU. + pub fn on_device(&self, device_id: i32) -> Self { + Self::build_on_device( + std::sync::Arc::clone(&self.toplevel), + self.commitment_parameters, + self.fri_parameters, + Some(device_id), + #[cfg(feature = "cuda")] + Some(std::sync::Arc::clone(&self.trace_provider)), + ) + } + + fn build_on_device( + toplevel: std::sync::Arc, + commitment_parameters: CommitmentParameters, + fri_parameters: FriParameters, + device_id: Option, + #[cfg(feature = "cuda")] trace_provider: Option< + std::sync::Arc, + >, ) -> Self { let claim_shapes = toplevel.checked_claim_shapes().expect("invalid Aiur lookup shapes"); toplevel.validate_row_counts().expect("invalid Aiur control counts"); + #[cfg(feature = "cuda")] + let trace_provider = trace_provider.unwrap_or_else(|| { + std::sync::Arc::new(crate::gpu_trace::TraceProvider::from_env( + toplevel.clone(), + )) + }); let mut circuit_inputs: Vec> = Vec::new(); let mut slot_widths: Vec> = Vec::new(); @@ -335,7 +384,8 @@ impl AiurSystem { 2, ); - let config = AiurConfig::new(commitment_parameters, fri_parameters); + let config = + AiurConfig::with_device(commitment_parameters, fri_parameters, device_id); let (mut system, key) = System::new(config, circuit_inputs); let blowup = system.config.max_quotient_degree(); for circuit in &mut system.circuits { @@ -357,6 +407,8 @@ impl AiurSystem { key, toplevel, claim_shapes, + #[cfg(feature = "cuda")] + trace_provider, commitment_parameters, fri_parameters, slot_widths, @@ -641,6 +693,7 @@ impl AiurSystem { O: FnOnce() -> Vec, S: FnMut(usize) -> Result, String>, { + #[cfg(feature = "texray")] tracing_texray::examine_current(); if count == 0 { return Err("no records to prove".into()); @@ -685,12 +738,13 @@ impl AiurSystem { round = 1 ) .entered(); - let witness = self.shard_witness( + let witness = self.prepared_shard_witness( supplied.record(), supplied.io(), plan, &indexes[*r], s, + BatchRound::One, ); return Some((claims, witness)); } @@ -766,12 +820,13 @@ impl AiurSystem { round = 2 ) .entered(); - self.shard_witness( + self.prepared_shard_witness( supplied.record(), supplied.io(), &plans[r], &indexes[r], s, + BatchRound::Two, ) }); Ok((claim, proof)) @@ -852,7 +907,14 @@ impl AiurSystem { }; let _g = tracing::info_span!("aiur/witness", shard, round = round_number) .entered(); - self.shard_witness(&query_record, io_buffer, plan, &index, shard) + self.prepared_shard_witness( + &query_record, + io_buffer, + plan, + &index, + shard, + round, + ) }; let proof = match retention { // A retained stage 1 is committed once and serves round two's lookups. @@ -891,6 +953,7 @@ impl AiurSystem { input: &[G], io_buffer: &mut IOBuffer, ) -> (Vec, AiurProof) { + #[cfg(feature = "texray")] tracing_texray::examine_current(); // Execute the Aiur bytecode. @@ -984,6 +1047,7 @@ impl AiurSystem { &mut IOBuffer, ) -> Result<(QueryRecord, Vec), ExecError>, { + #[cfg(feature = "texray")] tracing_texray::examine_current(); let prepared = match self.prepare_ixvm_within_budget( fun_idx, @@ -1350,6 +1414,144 @@ mod tests { assert_eq!(calibrate_prover_rss(usize::MAX), usize::MAX); } + #[cfg(feature = "cuda-trace-codegen")] + #[test] + fn codegen_blake3_regenerated_batch_matches_cpu() { + use multi_stark::p3_matrix::Matrix; + use multi_stark::witness::{PreparedWitness, TraceSource}; + let (cp, fp) = test_parameters(); + let program = (crate::trace_codegen::tests::blake3::PROGRAM.expected)(); + let mut system = AiurSystem::build(program, cp, fp); + let provider = crate::gpu_trace::TraceProvider::Generated( + crate::trace_codegen::tests::blake3_cuda::CUDA + .register( + &crate::trace_codegen::tests::blake3::PROGRAM, + system.toplevel.clone(), + ) + .unwrap(), + ); + system.trace_provider = std::sync::Arc::new(provider); + let other = system.on_device(0); + assert!(std::sync::Arc::ptr_eq( + &system.trace_provider, + &other.trace_provider, + )); + let mut io = empty_io_buffer(); + let mut input = vec![G::ZERO]; + input.extend((0..128).map(|i| G::from_usize((i * 37 + 19) % 256))); + let (record, output) = + system.toplevel().execute(0, input.clone(), &mut io).unwrap(); + let mut plan = system.plan_shards(&record, None); + assert_eq!(plan.num_shards(), 1); + assert_eq!(plan.shards[0].rows[0], 0..8); + plan.shards[0].rows[0] = 0..4; + plan.shards.push(ShardRows { rows: vec![4..8, 0..0, 0..0] }); + let index = system.row_index(&record, &plan); + let mut claim = vec![function_channel(), G::ZERO]; + claim.extend(input); + claim.extend(output); + let claims = vec![vec![claim.clone()], vec![]]; + let build = |shard: usize, + round: Option| + -> PreparedWitness { + match round { + Some(round) => system + .prepared_shard_witness(&record, &io, &plan, &index, shard, round), + None => system.shard_witness(&record, &io, &plan, &index, shard).into(), + } + }; + let witness = build(0, Some(BatchRound::Two)); + let TraceSource::Generated(source) = &witness.traces[0] else { + panic!("missing GPU source") + }; + let weak_source = std::sync::Arc::downgrade(source); + let stage1 = system.system.prove_stage_1(witness); + drop(stage1); + assert!( + weak_source.upgrade().is_none(), + "released stage one retained a generated source or LDE" + ); + + let reference = system.system.prove_batch_with( + &system.key, + &claims, + vec![], + Retention::Regenerate, + |shard| build(shard, None), + ); + system.verify(&claim, &reference).unwrap(); + // Round one keeps no seeds on the device; round two's two generated + // sources upload theirs once each and the lookup pass releases them. + use crate::trace_codegen::cuda::{SEED_CACHE_UPLOADS, seed_cache_bytes}; + use std::sync::atomic::Ordering; + let uploads = SEED_CACHE_UPLOADS.load(Ordering::Acquire); + let witnesses: Vec<_> = (0..claims.len()) + .map(|shard| build(shard, Some(BatchRound::One))) + .collect(); + let sources: Vec<_> = witnesses + .iter() + .flat_map(|witness| &witness.traces) + .filter_map(|trace| match trace { + TraceSource::Generated(source) => { + Some(std::sync::Arc::downgrade(source)) + }, + TraceSource::Host(_) => None, + }) + .collect(); + let barrier = system.system.batch_round_one( + claims.iter().cloned().zip(witnesses), + Retention::Regenerate, + ); + assert!( + sources.iter().all(|source| source.upgrade().is_none()), + "round one retained a generated source or LDE across the barrier" + ); + assert_eq!(SEED_CACHE_UPLOADS.load(Ordering::Acquire), uploads); + let proof = + system.system.batch_round_two(&system.key, barrier, vec![], |shard| { + build(shard, Some(BatchRound::Two)) + }); + assert_eq!(SEED_CACHE_UPLOADS.load(Ordering::Acquire), uploads + 2); + assert_eq!(seed_cache_bytes(0), 0, "round two released its seeds"); + system.verify(&claim, &proof).unwrap(); + assert_eq!( + proof.to_bytes().unwrap(), + reference.to_bytes().unwrap(), + "GPU generation changed proof bytes" + ); + let corrupt = || { + let mut witness = build(0, Some(BatchRound::Two)); + let source = witness.traces.remove(0); + let mut trace = source.materialize(); + let row = (0..trace.height()) + .find(|&r| trace.values[r * 533] != G::from_u8(7)) + .unwrap(); + // This auxiliary supplies both the recursive call and its returned value. + trace.values[row * 533 + 501] += G::ONE; + witness.traces.insert(0, TraceSource::Host(trace)); + witness + }; + let fresh = system.system.prove_stage_1(corrupt()); + assert_ne!( + fresh.stage_1_trace_commit, reference.preamble.headers[0].stage_1_trace, + "independent commitment must detect incorrect regeneration" + ); + drop(fresh); + let barrier = system.system.batch_round_one( + claims + .iter() + .enumerate() + .map(|(shard, c)| (c.clone(), build(shard, Some(BatchRound::One)))), + Retention::Regenerate, + ); + let bad = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + system.system.batch_round_two(&system.key, barrier, vec![], |shard| { + if shard == 0 { corrupt() } else { build(shard, Some(BatchRound::Two)) } + }) + })); + assert!(bad.is_err(), "round two must reject corrupted regenerated values"); + } + /// Small FRI parameters mirroring `vk_codec`'s test config: cheap to prove /// while still exercising the full FRI pipeline (log_blowup 1, 64 queries, /// no proof-of-work). @@ -1597,6 +1799,68 @@ mod tests { ); } + #[cfg(feature = "cuda")] + #[test] + fn record_pool_workspace_excludes_shape_only_lookup_payloads() { + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); + let record = QueryRecord::new(system.toplevel()); + let mut plan = system.single_shard_plan(&record); + plan.shards[0].rows[0] = 0..(1 << 20); + let full = system.shard_host_workspace(&plan, 0, true); + let shape_only = system.shard_host_workspace(&plan, 0, false); + assert!(shape_only < 512 << 20, "shape-only workspace: {shape_only}"); + assert!(full > 512 << 20, "materialized lookup workspace: {full}"); + } + + #[cfg(feature = "cuda")] + #[test] + #[ignore = "requires two CUDA devices"] + fn record_pool_prepared_moves_between_devices() { + use crate::execute::bind_record_reservation; + use crate::record_pool::{ProverBudget, RecordPool}; + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); + let producer = system.on_device(0); + let consumer = system.on_device(1); + assert_eq!( + crate::vk_codec::aiur_system_to_bytes(&producer).unwrap(), + crate::vk_codec::aiur_system_to_bytes(&consumer).unwrap() + ); + let pool = RecordPool::for_provers( + 4096, + 4096, + ProverBudget { trace_cells: 1_000_000, host_workspace: 1 << 30 }, + ); + let reservation = pool.try_admit().unwrap().unwrap(); + let binding = bind_record_reservation(&reservation); + let input = [G::from_u64(3), G::from_u64(5)]; + let prepared = producer + .prepare_ixvm_within_budget( + 0, + &input, + &mut empty_io_buffer(), + |top, fun, input, io| top.execute(fun, input, io), + Some(1), + true, + None, + ) + .unwrap_or_else(|_| { + panic!("pooled planning used the obsolete per-record ceiling") + }); + let retained = crate::execute::record_retained_bytes(&prepared.record); + assert_eq!(pool.stats().reserved, retained); + drop(binding); + drop(reservation); + assert_eq!(pool.stats().reserved, retained); + let (claim, proof, _) = + std::thread::spawn(move || consumer.prove_prepared(prepared)) + .join() + .unwrap(); + assert_eq!(pool.stats().reserved, 0); + system.verify(&claim, &proof).unwrap(); + } + /// Exercise promotion of a cached unconstrained call through nested calls. /// /// `f` first computes `g(x)` as an unconstrained hint, then calls `g(x)` diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index e867b0a50..9035f280c 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -147,6 +147,49 @@ pub(crate) fn witness_metadata_bytes(members: usize, rows: usize) -> usize { pub type QueryPosition = (usize, usize); impl Toplevel { + #[cfg(test)] + pub(crate) fn main_row_for_test( + &self, + circuit_index: usize, + member: usize, + query: usize, + record: &QueryRecord, + io: &IOBuffer, + ) -> Vec { + let circuit = &self.circuits[circuit_index]; + let function = &self.functions[member]; + let offset: usize = circuit + .members + .iter() + .take_while(|&&i| i != member) + .map(|&i| self.functions[i].layout.selectors) + .sum(); + assert!(circuit.members.contains(&member)); + let (inputs, result) = + record.function_queries[member].get_index(query).unwrap(); + let mut row = vec![G::ZERO; circuit.layout.width()]; + let mut slice = ColumnMutSlice::from_slice( + function, + &circuit.layout, + offset, + &mut row, + None, + ); + function.populate_row( + &mut ColumnIndex { auxiliary: 0, lookup: 1 }, + &mut slice, + TraceContext { + function_index: G::from_usize(member), + multiplicity: result.multiplicity, + inputs, + output: result.output, + query_record: record, + }, + io, + ); + row + } + /// The number of rows function circuit `circuit_index` contributes: its /// members' queries with a nonzero multiplicity, in member order then /// record order. The unit [`Self::witness_data_range`] indexes. diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs index 523fb0942..20d589027 100644 --- a/crates/ffi/src/aiur/aggregate.rs +++ b/crates/ffi/src/aiur/aggregate.rs @@ -17,7 +17,7 @@ use ix_kernel::shard::ShardManifest; use ixvm_codegen::env_handle::EnvHandle; use plan::{ FoldPolicy, PlanIdentity, PlanOp, SlotSpec, build_specs, - build_statement_specs, plan_replay, + build_statement_specs, plan_replay, subtree_plan, }; use prepare::{PreparedShard, prepare_run, validate_root_statement}; use protocol::{ChildKind, allowed_blob, inner_claim}; @@ -35,6 +35,7 @@ pub(crate) use store::write_store; use store::{load_input_proofs, persist_wrapper, wrapper_address}; mod ffi; +pub mod lanes; mod plan; mod prepare; mod protocol; @@ -155,6 +156,7 @@ fn print_plan( } fn run(config: RunConfig<'_>) -> Result { + crate::profile::init(); if config.cache_fri_bytes.len() != 40 { return Err(format!( "aggregate cache FRI serialization is {} bytes, expected 40", diff --git a/crates/ffi/src/aiur/aggregate/ffi.rs b/crates/ffi/src/aiur/aggregate/ffi.rs index 114418d26..0459d7803 100644 --- a/crates/ffi/src/aiur/aggregate/ffi.rs +++ b/crates/ffi/src/aiur/aggregate/ffi.rs @@ -13,7 +13,10 @@ use lean_ffi::object::{ LeanOwned, LeanProd, }; -use super::{RunConfig, expected_from_manifest, panic_text, run}; +use super::{ + PlanOp, RunConfig, build_statement_specs, expected_from_manifest, panic_text, + prepare_run, run, subtree_plan, +}; use crate::lean::LeanAiurAggregateExpected; use aiur::execute::IOBuffer; use ix_kernel::shard::ShardManifest; @@ -58,6 +61,86 @@ extern "C" fn rs_aiur_aggregate_expected( } } +/// `AiurSystem.aggregateSubtreePlan`: the plan cut into `subtrees` for +/// `ix prove --lanes`. Rows in post-order: `[0, slot, ids…]` for a subtree +/// (its root slot, then the manifest ids of the shards under it, sorted; +/// one id when the subtree is a raw leaf) and `[1, slot, left, right]` for +/// each join above the frontier, the root last. A tree too small to cut +/// into `subtrees` simply yields fewer. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_aggregate_subtree_plan( + env_handle: LeanExternal>, + manifest_path: LeanString>, + structural_above: LeanNat>, + subtree_size: LeanNat>, +) -> LeanExcept { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let subtree_size = lean_unbox_nat_as_usize(subtree_size.inner()); + if subtree_size == 0 { + return Err("the subtree size must be at least one leaf".to_string()); + } + let manifest_bytes = + fs::read(Path::new(manifest_path.as_str())).map_err(|error| { + format!("read manifest {}: {error}", manifest_path.as_str()) + })?; + let manifest = ShardManifest::from_bytes(&manifest_bytes) + .map_err(|error| format!("manifest parse failed: {error}"))?; + let prepared = prepare_run(&env_handle.get().env, &manifest)?; + let specs = build_statement_specs( + &prepared, + lean_unbox_nat_as_usize(structural_above.inner()), + )?; + let ops: Vec = specs.iter().map(|spec| spec.op).collect(); + let (frontier, upper) = subtree_plan(&ops, subtree_size); + let mut rows: Vec> = + Vec::with_capacity(frontier.len() + upper.len()); + for &slot in &frontier { + let mut ids = Vec::new(); + let mut stack = vec![slot]; + while let Some(index) = stack.pop() { + match ops[index] { + PlanOp::Leaf(shard) => { + ids.push(prepared.shards[shard].original_id as usize); + }, + PlanOp::Join(left, right) => { + stack.push(left); + stack.push(right); + }, + } + } + ids.sort_unstable(); + let mut row = vec![0, slot]; + row.extend(ids); + rows.push(row); + } + for &slot in &upper { + let PlanOp::Join(left, right) = ops[slot] else { + unreachable!("upper nodes are joins") + }; + rows.push(vec![1, slot, left, right]); + } + Ok(rows) + })); + match result { + Ok(Ok(rows)) => { + let outer = LeanArray::alloc(rows.len()); + for (at, row) in rows.iter().enumerate() { + let inner = LeanArray::alloc(row.len()); + for (index, value) in row.iter().enumerate() { + inner.set(index, LeanOwned::box_usize(*value)); + } + outer.set(at, inner); + } + LeanExcept::ok(outer) + }, + Ok(Err(error)) => LeanExcept::error_string(&error), + Err(payload) => LeanExcept::error_string(&format!( + "native subtree planning panicked: {}", + panic_text(&payload) + )), + } +} + /// Production FFI called once after Lean has compiled the IxVM and ixAggr /// systems. Proof addresses are newline-separated to keep the ABI flat. #[unsafe(no_mangle)] diff --git a/crates/ffi/src/aiur/aggregate/lanes.rs b/crates/ffi/src/aiur/aggregate/lanes.rs new file mode 100644 index 000000000..73902bd1e --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes.rs @@ -0,0 +1,1186 @@ +//! Shared CPU preparation feeding one resident prover per GPU. +//! +//! Claims and ready joins execute through one bounded queue. Prepared +//! records go to the next available GPU, with joins taking priority. +//! Record reservations follow their storage through both proving rounds. +//! Under memory pressure executions wait for capacity; mutual blocking +//! cancels the youngest waiter so the selected execution can finish. + +mod checkpoint; +mod limits; +mod queue; +use limits::{HostBudget, cgroup_memory_limit}; +use queue::WorkQueue; + +use std::collections::VecDeque; +use std::sync::mpsc; +use std::time::Instant; + +use aiur::execute::bind_record_reservation; +use aiur::record_pool::{ + PoolStats, ProverBudget, RecordPool, RecordReservation, +}; +use aiur::synthesis::ShardRetention as Retention; +use ixvm_codegen::aiur_ixvm_runner::execute_ixvm; +use ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness; + +use super::prepare::PreparedRun; +use super::protocol::serialize_claims; +use super::prove::{ + PrepareFailure, Slot, StagedSlot, finish_slot, prepare_slot, +}; +use super::store::{decode_wrapper, load_cached, read_store}; +use super::*; +use crate::aiur::lean_unbox_nat_as_usize; +use aiur::synthesis::{GatedProve, PreparedProve}; +use ix_common::address::Address; +use ixon::{Claim, Proof as IxonProof}; +use lean_ffi::object::{ + LeanBorrowed, LeanByteArray, LeanExcept, LeanExternal, LeanNat, LeanOwned, + LeanString, +}; +use rustc_hash::FxHashSet; +use std::thread; + +pub struct Config { + pub lanes: usize, + /// Per-GPU host budget in bytes, multiplied by `lanes`; 0 detects one + /// process-wide allowance. + pub max_ram_bytes: usize, + /// Preparation threads per GPU, combined into one process-wide pool. + pub exec_jobs: usize, + pub structural_above: usize, + pub cache_fri_bytes: Vec, + pub out_manifest: Option, +} + +/// The default ceiling on one execution record's counted bytes: large +/// enough that any single constant of the environments proven so far +/// executes as one claim, small enough that one record cannot take most +/// of a four-lane pool. A claim over it is bisected rather than executed. +/// `AIUR_RECORD_MAX_BYTES` overrides it. +const DEFAULT_RECORD_MAX_BYTES: usize = 128 << 30; + +enum PassOutcome { + Complete { root: String, unproven: usize }, + Refine(Vec), +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Work { + Claim(usize), + Join(usize), + Root, +} + +struct Prep { + work: Work, + children: Vec>, + reservation: RecordReservation, +} + +/// A prepared host record consumed by whichever GPU becomes available. +enum Item { + Claim { + shard: usize, + claim: Claim, + claim_bytes: Vec, + prepared: Box, + }, + Join { + slot: usize, + staged: Box, + }, + Root { + slot: usize, + staged: Box, + }, +} + +impl Item { + fn work(&self) -> Work { + match self { + Self::Claim { shard, .. } => Work::Claim(*shard), + Self::Join { slot, .. } => Work::Join(*slot), + Self::Root { .. } => Work::Root, + } + } +} + +enum Event { + ExecutionStarted { executor: usize, work: Work }, + Prepared { executor: usize, work: Work, record_bytes: usize, secs: f64 }, + PrepAvailable, + PrepFailed { executor: usize, work: Work, failure: PrepareFailure }, + Proving { worker: usize, work: Work }, + Proven { worker: usize, work: Work, result: Result, String> }, + RootProven { worker: usize, result: Result }, +} + +struct ShutdownRun<'a> { + pool: &'a RecordPool, + prep: &'a WorkQueue, + items: &'a WorkQueue, +} + +impl Drop for ShutdownRun<'_> { + fn drop(&mut self) { + self.pool.shutdown(); + self.prep.close(); + self.items.close(); + } +} + +/// The shard-proof index entry of a claim, written like Stage 1 writes it. +fn index_claim( + index_dir: &Path, + claim_bytes: &[u8], + address: &Address, +) -> Result<(), String> { + fs::create_dir_all(index_dir) + .map_err(|error| format!("create {}: {error}", index_dir.display()))?; + let digest = Address::hash(claim_bytes); + let temporary = + index_dir.join(format!("{}.tmp.{}", digest.hex(), std::process::id())); + fs::write(&temporary, format!("{}\n", address.hex())) + .and_then(|()| fs::rename(&temporary, index_dir.join(digest.hex()))) + .map_err(|error| format!("shard-proof index: {error}")) +} + +/// A claim's proof from the shard-proof index, verified natively against +/// the claim this run expects, as a raw leaf slot; `None` when absent or +/// not acceptable, never an error. +fn resume_leaf( + ctx: ProveContext<'_>, + index_dir: &Path, + slot_index: usize, + shard: usize, +) -> Option { + let spec = &ctx.specs[slot_index]; + let statement = &ctx.prepared[shard].statement; + let digest = Address::hash(&statement.claim_bytes); + let raw = fs::read_to_string(index_dir.join(digest.hex())).ok()?; + let address = Address::from_hex(raw.trim())?; + let bytes = read_store(ctx.store_dir, &address).ok()?; + if Address::hash(&bytes) != address { + return None; + } + let wrapper = decode_wrapper(&bytes).ok()?; + if wrapper.claim != statement.claim { + return None; + } + let proof = AiurProof::from_bytes(&wrapper.proof).ok()?; + let inner = inner_claim(ctx.verify_idx, &statement.claim_bytes); + ctx.ixvm_system.verify(&inner, &proof).ok()?; + Some(Slot { + kind: ChildKind::Ixvm, + statement: spec.statement.clone(), + outer_claim: inner.clone(), + proof, + proof_address: Some(address), + claims_bytes: serialize_claims(&[&inner]), + }) +} + +fn prepare_loop( + ctx: ProveContext<'_>, + executor: usize, + env: &ixon::Env, + owned: &[Vec
], + max_ram_bytes: Option, + prep: &WorkQueue, + items: &WorkQueue, + events: &mpsc::Sender, +) { + while let Some(task) = prep.pop() { + let Prep { work, children, reservation } = task; + let began = Instant::now(); + let _ = events.send(Event::ExecutionStarted { executor, work }); + let binding = bind_record_reservation(&reservation); + let outcome = (|| -> Result { + match work { + Work::Claim(shard) => { + let (claim, input, mut io) = + build_shard_check_env_witness(env, &owned[shard]) + .map_err(|e| format!("witness build: {e}"))?; + let prepared = match ctx.ixvm_system.prepare_ixvm_within_budget( + ctx.verify_idx, &input, &mut io, execute_ixvm, + max_ram_bytes, true, Some(Retention::Regenerate), + ) { + Ok(prepared) => prepared, + Err(GatedProve::Failed(aiur::execute::ExecError::RecordBudgetExceeded { bytes, cap })) => { + return Err(PrepareFailure::OverRecordCap { bytes, cap }); + }, + Err(GatedProve::Failed(aiur::execute::ExecError::RecordMemoryContention)) => { + return Err(PrepareFailure::MemoryContention); + }, + Err(GatedProve::Failed(error)) => return Err(format!("execution failed: {error}").into()), + Err(GatedProve::Split { peak, .. }) => return Err(format!( + "no trace-shard count fits the process budget (whole-execution peak {peak} B)" + ).into()), + Err(_) => return Err("execution did not prepare a proof".into()), + }; + let mut claim_bytes = Vec::new(); + claim.put(&mut claim_bytes); + Ok(Item::Claim { + shard, + claim, + claim_bytes, + prepared: Box::new(prepared), + }) + }, + Work::Join(slot) => { + let staged = prepare_slot(ctx, slot, &children)?; + Ok(Item::Join { slot, staged: Box::new(staged) }) + }, + Work::Root => { + let slot = ctx.specs.len() - 1; + let staged = prepare_slot(ctx, slot, &children)?; + Ok(Item::Root { slot, staged: Box::new(staged) }) + }, + } + })(); + reservation.finish_execution(); + let measured = reservation.bytes(); + drop(binding); + drop(reservation); + match outcome { + Ok(item) => { + // Publish preparation before handing ownership to a prover. + let _ = events.send(Event::Prepared { + executor, + work, + record_bytes: measured, + secs: began.elapsed().as_secs_f64(), + }); + if items.push(item, !matches!(work, Work::Claim(_))).is_err() { + return; + } + // A producer waiting on a full prepared queue still occupies its + // execution slot and retains the record's memory charge. + let _ = events.send(Event::PrepAvailable); + }, + Err(failure) => { + let _ = events.send(Event::PrepFailed { executor, work, failure }); + }, + } + } +} + +/// Each job's proving rounds stay on this device; completed proofs +/// release records and make dependent joins ready. +fn prove_loop( + ctx: ProveContext<'_>, + worker: usize, + prepared_run: &PreparedRun, + leaf_slot: &[usize], + index_dir: &Path, + items: &WorkQueue, + pool: &RecordPool, + events: &mpsc::Sender, +) { + while let Some(item) = items.pop() { + let _metrics = + tracing::info_span!(target: "prover_metrics", "aiur/metrics_unit", + work = ?item.work(), worker) + .entered(); + let _ = events.send(Event::Proving { worker, work: item.work() }); + match item { + Item::Claim { shard, claim, claim_bytes, prepared } => { + let result = (|| -> Result, String> { + let (_, proof, _) = ctx.ixvm_system.prove_prepared(*prepared); + let proof_bytes = proof + .to_bytes() + .map_err(|e| format!("proof serialization: {e}"))?; + let wrapper = IxonProof::new(claim, proof_bytes); + let mut wrapper_bytes = Vec::new(); + wrapper.put(&mut wrapper_bytes); + write_store(ctx.store_dir, &claim_bytes)?; + let address = write_store(ctx.store_dir, &wrapper_bytes)?; + index_claim(index_dir, &claim_bytes, &address)?; + let inner = inner_claim(ctx.verify_idx, &claim_bytes); + Ok(Arc::new(Slot { + kind: ChildKind::Ixvm, + statement: ctx.specs[leaf_slot[shard]].statement.clone(), + outer_claim: inner.clone(), + proof, + proof_address: Some(address), + claims_bytes: serialize_claims(&[&inner]), + })) + })(); + let _ = events.send(Event::Proven { + worker, + work: Work::Claim(shard), + result, + }); + }, + Item::Join { slot, staged } => { + let result = finish_slot(ctx, slot, *staged); + let _ = + events.send(Event::Proven { worker, work: Work::Join(slot), result }); + }, + Item::Root { slot, staged } => { + let result = (|| -> Result { + let root = finish_slot(ctx, slot, *staged)?; + validate_root_statement(prepared_run, &root.statement)?; + // Wrap until the final proof is a single trace shard. + let mut wrapped: Option = None; + loop { + let current = wrapped.as_ref().unwrap_or(&root.proof); + let shards = current.preamble.headers.len(); + if shards <= 1 { + break; + } + let reservation = pool + .try_admit() + .map_err(|error| format!("root wrap admission: {error:?}"))? + .ok_or("root wrap cannot acquire record capacity")?; + let binding = bind_record_reservation(&reservation); + let next = wrap_root(ctx, &root, current)?; + drop(binding); + drop(reservation); + if next.preamble.headers.len() >= shards { + break; + } + wrapped = Some(next); + } + let proof = wrapped.as_ref().unwrap_or(&root.proof); + ctx.aggr_system.verify(&root.outer_claim, proof).map_err( + |error| { + format!("aggregate root proof failed verification: {error:?}") + }, + )?; + let address = match (&wrapped, &root.proof_address) { + (None, Some(address)) => address.clone(), + _ => persist_wrapper(ctx.store_dir, &root.statement, proof)?, + }; + Ok(address.hex()) + })(); + let _ = events.send(Event::RootProven { worker, result }); + }, + } + } +} + +/// The whole run. Prints progress on stderr and returns the verified +/// root address. +/// The composed verdict: every claim proof the run holds, proved or +/// reused, verified natively against its claim, in parallel. Returns the +/// failures and the number of claims without a proof to verify: claims +/// retired under a cached join whose proof the index no longer holds, +/// which rest on that join's own native verification when it was loaded. +fn composed_verdict( + ixvm: &AiurSystem, + verify_idx: usize, + prepared: &PreparedRun, + leaves: &[Option>], +) -> (Vec, usize) { + let failures = leaves + .par_iter() + .enumerate() + .filter_map(|(shard, slot)| { + let slot = slot.as_ref()?; + let inner = + inner_claim(verify_idx, &prepared.shards[shard].statement.claim_bytes); + ixvm.verify(&inner, &slot.proof).err().map(|error| { + format!( + "claim {}: proof fails verification: {error:?}", + prepared.shards[shard].original_id + ) + }) + }) + .collect(); + (failures, leaves.iter().filter(|slot| slot.is_none()).count()) +} + +/// Percentile `p` (0–100) of `sorted`, nearest rank; 0 when empty. +fn percentile(sorted: &[usize], p: usize) -> usize { + if sorted.is_empty() { + return 0; + } + let rank = (sorted.len() * p).div_ceil(100).max(1); + sorted[rank - 1] +} + +/// Observed record sizes and execution times, with a p90-based candidate +/// cut under inverse scaling. The initial reservation is admission credit, +/// not a per-record size limit. +#[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)] +#[allow(clippy::cast_sign_loss)] +fn record_summary( + say: &dyn Fn(&str), + shards: usize, + share: Option, + record_budget: Option, + contention_retries: usize, + claims: &[(usize, usize, f64)], + joins: &[(usize, usize, f64)], +) { + let stats = |units: &[(usize, usize, f64)]| -> Option { + if units.is_empty() { + return None; + } + let mut bytes: Vec = units.iter().map(|u| u.1).collect(); + bytes.sort_unstable(); + let total: usize = bytes.iter().sum(); + let (largest_id, largest, _) = + units.iter().max_by_key(|u| u.1).copied().expect("nonempty"); + let secs: Vec = units.iter().map(|u| u.2).collect(); + let mean_secs = secs.iter().sum::() / secs.len() as f64; + let max_secs = secs.iter().copied().fold(0.0_f64, f64::max); + Some(format!( + "{} executed: record mean {} GiB, p50 {} GiB, p90 {} GiB, max {} GiB (unit {largest_id}); execution mean {mean_secs:.1}s, max {max_secs:.1}s", + units.len(), + format_gib(total / units.len()), + format_gib(percentile(&bytes, 50)), + format_gib(percentile(&bytes, 90)), + format_gib(largest), + )) + }; + if let Some(line) = stats(claims) { + say(&format!("calibration: claims {line}")); + } + if let Some(line) = stats(joins) { + say(&format!("calibration: joins {line}")); + } + let (Some(share), Some(budget)) = (share, record_budget) else { + say("calibration: no --max-ram, so no share to calibrate against"); + return; + }; + if claims.len() != shards { + say(&format!( + "calibration: shard-count candidate unavailable; measured {} of {shards} claim records in the current partition", + claims.len() + )); + return; + } + let largest_claim = claims.iter().map(|u| u.1).max().unwrap_or(0); + let largest_join = joins.iter().map(|u| u.1).max().unwrap_or(0); + let mut claim_sizes: Vec<_> = claims.iter().map(|u| u.1).collect(); + claim_sizes.sort_unstable(); + let reanchored = ((shards as f64) * (percentile(&claim_sizes, 90) as f64) + / (share as f64)) + .ceil() as usize; + say(&format!( + "calibration: {shards} shards at a {} GiB initial reservation ({} GiB shared record budget): largest claim record {}% of the initial reservation, largest join record {}%, {contention_retries} contention retry/retries; p90-scaled candidate {reanchored} shard(s) at this initial reservation (claims measured this run only; a resumed run measures fewer)", + format_gib(share), + format_gib(budget), + largest_claim * 100 / share.max(1), + largest_join * 100 / share.max(1), + )); +} + +pub fn run( + cfg: &Config, + ixvm: &AiurSystem, + aggr: &AiurSystem, + env: &ixon::Env, + manifest_path: &Path, + verify_idx: usize, + aggr_idx: usize, +) -> Result { + crate::profile::init(); + let say = |m: &str| eprintln!("[lanes] {m}"); + if cfg.cache_fri_bytes.len() != 40 { + return Err("aggregate cache FRI serialization must be 40 bytes".into()); + } + let started = Instant::now(); + let manifest_bytes = fs::read(manifest_path).map_err(|error| { + format!("read manifest {}: {error}", manifest_path.display()) + })?; + let source = ShardManifest::from_bytes(&manifest_bytes) + .map_err(|error| format!("manifest parse failed: {error}"))?; + let home = std::env::var_os("HOME").ok_or("no HOME environment variable")?; + let cache_root = std::env::var_os("AIUR_LANES_CACHE_DIR") + .map_or_else(|| PathBuf::from(home).join(".ix/cache"), PathBuf::from); + let checkpoint_path = cache_root + .join("refined-manifests") + .join(format!("{}.ixes", Address::hash(&manifest_bytes).hex())); + let mut manifest = match fs::read(&checkpoint_path) { + Ok(bytes) => { + let refined = ShardManifest::from_bytes(&bytes).map_err(|error| { + format!("refined manifest {}: {error}", checkpoint_path.display()) + })?; + say(&format!( + "resuming refined partition with {} claims from {}", + refined.num_shards, + checkpoint_path.display() + )); + refined + }, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => source, + Err(error) => { + return Err(format!("read {}: {error}", checkpoint_path.display())); + }, + }; + let record_max_bytes = match std::env::var("AIUR_RECORD_MAX_BYTES") { + Ok(value) => value + .parse::() + .ok() + .filter(|&n| n > 0) + .ok_or("AIUR_RECORD_MAX_BYTES must be a positive integer")?, + Err(std::env::VarError::NotPresent) => DEFAULT_RECORD_MAX_BYTES, + Err(error) => return Err(format!("AIUR_RECORD_MAX_BYTES: {error}")), + }; + let mut profile = None; + let mut pool_stats = PoolStats::default(); + loop { + match run_manifest( + cfg, + ixvm, + aggr, + env, + &manifest, + verify_idx, + aggr_idx, + &cache_root, + record_max_bytes, + started, + &mut pool_stats, + )? { + PassOutcome::Complete { root, unproven } => { + if let Some(path) = &cfg.out_manifest { + checkpoint::write_atomic(path, &manifest.to_bytes())?; + say(&format!("final partition: {}", path.display())); + } + say(&format!( + "record pool: peak granted {} GiB, {} growth waits ({:.1}s summed across executions), {} contention retries", + format_gib(pool_stats.peak_reserved), + pool_stats.waits, + pool_stats.wait_time.as_secs_f64(), + pool_stats.retries, + )); + let coverage = if unproven == 0 { + String::new() + } else { + format!( + " ({unproven} claims retired under verified cached joins have no indexed proof)" + ) + }; + say(&format!( + "root {root} verified; composed verdict OK{coverage}; end to end {}s", + started.elapsed().as_secs() + )); + return Ok(root); + }, + PassOutcome::Refine(ids) => { + let profile = profile + .get_or_insert_with(|| crate::kernel::static_block_profile(env)); + let (refined, parts) = manifest.bisect_leaves(profile, &ids)?; + checkpoint::write_atomic(&checkpoint_path, &refined.to_bytes())?; + for (&id, parts) in ids.iter().zip(parts) { + say(&format!("split claim {id} into claims {parts:?}")); + } + say(&format!( + "refined partition: {} claims, saved to {}; continuing with completed proofs", + refined.num_shards, + checkpoint_path.display() + )); + manifest = refined; + }, + } + } +} + +fn run_manifest( + cfg: &Config, + ixvm: &AiurSystem, + aggr: &AiurSystem, + env: &ixon::Env, + manifest: &ShardManifest, + verify_idx: usize, + aggr_idx: usize, + cache_root: &Path, + record_max_bytes: usize, + started: Instant, + pool_stats: &mut PoolStats, +) -> Result { + let say = |m: &str| eprintln!("[lanes] {m}"); + let prepared = prepare_run(env, manifest)?; + let ixvm_vk = aiur::vk_codec::aiur_system_to_bytes(ixvm) + .map_err(|error| format!("IxVM VK serialization failed: {error}"))?; + let aggr_vk = aiur::vk_codec::aiur_system_to_bytes(aggr) + .map_err(|error| format!("ixAggr VK serialization failed: {error}"))?; + let allowed = allowed_blob(&ixvm_vk, verify_idx, &aggr_vk, aggr_idx); + let specs = build_specs( + &prepared, + PlanIdentity { + verify_idx, + aggr_idx, + aggr_vk: &aggr_vk, + allowed: &allowed, + cache_fri_bytes: &cfg.cache_fri_bytes, + }, + FoldPolicy { structural_above: cfg.structural_above, direct_joins: true }, + )?; + let count = specs.len(); + let root_slot = count.checked_sub(1).ok_or("empty plan")?; + let PlanOp::Join(root_left, root_right) = specs[root_slot].op else { + return Err("the manifest has one shard; there is nothing to join".into()); + }; + let shards = prepared.shards.len(); + let mut leaf_slot = vec![usize::MAX; shards]; + for (index, spec) in specs.iter().enumerate() { + if let PlanOp::Leaf(shard) = spec.op { + leaf_slot[shard] = index; + } + } + let owned: Vec> = prepared + .shards + .iter() + .map(|shard| { + let mut leaves = Vec::new(); + shard.statement.subjects.collect_leaves(&mut leaves); + leaves.sort_unstable(); + leaves + }) + .collect(); + + let home = std::env::var_os("HOME").ok_or("no HOME environment variable")?; + let ix_root = PathBuf::from(home).join(".ix"); + let store_dir = ix_root.join("store"); + let cache_dir = cache_root.join("aggregate"); + let index_dir = cache_root.join("shard-proofs"); + fs::create_dir_all(&cache_dir) + .map_err(|error| format!("create {}: {error}", cache_dir.display()))?; + + if cfg.lanes == 0 { + return Err("at least one lane is required".into()); + } + let exec_jobs = if cfg.exec_jobs == 0 { + let cores = thread::available_parallelism().map_or(1, usize::from); + (cores / cfg.lanes).max(1) + } else { + cfg.exec_jobs + }; + let executions = exec_jobs + .checked_mul(cfg.lanes) + .ok_or("execution thread count overflow")?; + let cells = match std::env::var("AIUR_TRACE_SHARD_MAX_CELLS") { + Ok(value) => value + .parse::() + .ok() + .filter(|&n| n > 0) + .ok_or("AIUR_TRACE_SHARD_MAX_CELLS must be a positive integer")?, + Err(std::env::VarError::NotPresent) => 1_500_000_000, + Err(error) => return Err(format!("AIUR_TRACE_SHARD_MAX_CELLS: {error}")), + }; + let cgroup_limit = cgroup_memory_limit(); + let host = HostBudget::new( + cfg.lanes, + executions, + cfg.max_ram_bytes, + super::super::protocol::detected_ram_budget(), + cgroup_limit, + cells, + )?; + let max_ram_bytes = Some(host.limit); + let pool = RecordPool::for_provers( + host.records, + host.initial, + ProverBudget { trace_cells: cells, host_workspace: host.workspace }, + ) + .with_record_limit(record_max_bytes); + say(&format!( + "host budget {} GiB process-wide (requested {} GiB per GPU, visible cgroup limit {}): {} GiB shared records, {} GiB workspace per GPU, {} GiB headroom; {executions} CPU executions, {} prepared queue slots; {} GiB initial reservation, growth waits for shared capacity; {cells} trace cells", + format_gib(host.limit), + format_gib(cfg.max_ram_bytes), + cgroup_limit.map_or_else( + || "unlimited or unavailable".into(), + |bytes| format!("{} GiB", format_gib(bytes)) + ), + format_gib(host.records), + format_gib(host.workspace), + format_gib(host.headroom), + cfg.lanes, + format_gib(host.initial.min(pool.record_limit())), + )); + say(&format!( + "per-record ceiling {} GiB; oversized environment claims are bisected automatically", + format_gib(pool.record_limit()) + )); + + // A prover pair per device, sharing the bytecode of the systems the + // CLI built. The verifying keys must not depend on the device: every + // cache key and claim binding is derived from them. + say(&format!("building {} resident workers", cfg.lanes)); + let systems: Vec<(AiurSystem, AiurSystem)> = (0..cfg.lanes) + .map(|g| { + let device = + i32::try_from(g).map_err(|error| format!("lane {g}: {error}"))?; + Ok((ixvm.on_device(device), aggr.on_device(device))) + }) + .collect::>()?; + for (g, (worker_ixvm, worker_aggr)) in systems.iter().enumerate() { + let same = + aiur::vk_codec::aiur_system_to_bytes(worker_ixvm).ok().as_deref() + == Some(ixvm_vk.as_slice()) + && aiur::vk_codec::aiur_system_to_bytes(worker_aggr).ok().as_deref() + == Some(aggr_vk.as_slice()); + if !same { + return Err(format!( + "the verifying key of the prover on device {g} differs from device 0's" + )); + } + } + + let contexts: Vec> = systems + .iter() + .map(|(worker_ixvm, worker_aggr)| ProveContext { + specs: &specs, + prepared: &prepared.shards, + proofs: None, + owner_by_address: &prepared.owner_by_address, + ixvm_system: worker_ixvm, + aggr_system: worker_aggr, + ixvm_vk: &ixvm_vk, + aggr_vk: &aggr_vk, + allowed: &allowed, + verify_idx, + aggr_idx, + store_dir: &store_dir, + cache_dir: Some(&cache_dir), + reprove_slot: None, + write_outputs: true, + wrap_budget: max_ram_bytes, + range_width: 0, + range_jobs: 1, + }) + .collect(); + + // Resume: cached joins from the root down retire their subtrees; + // indexed claim proofs stand in for their claims. + let mut slots: Vec>> = vec![None; count]; + let mut retired = vec![false; count]; + for index in (0..root_slot).rev() { + let spec = &specs[index]; + if retired[index] || spec.kind != ChildKind::Aggr { + continue; + } + let ctx = &contexts[0]; + let Some((proof, address)) = + load_cached(ctx.aggr_system, ctx.store_dir, ctx.cache_dir, index, spec) + else { + continue; + }; + slots[index] = Some(Arc::new(Slot { + kind: ChildKind::Aggr, + statement: spec.statement.clone(), + outer_claim: spec.outer_claim.clone(), + proof, + proof_address: Some(address), + claims_bytes: serialize_claims(&[&spec.outer_claim]), + })); + let mut stack = match spec.op { + PlanOp::Join(l, r) => vec![l, r], + PlanOp::Leaf(_) => Vec::new(), + }; + while let Some(slot) = stack.pop() { + if retired[slot] { + continue; + } + retired[slot] = true; + if let PlanOp::Join(l, r) = specs[slot].op { + stack.push(l); + stack.push(r); + } + } + } + let mut claim_done = vec![false; shards]; + let resumed: Vec> = (0..shards) + .into_par_iter() + // A claim retired under a cached join is still loaded when the index + // holds its proof, so the composed verdict can verify it independently. + .map(|shard| resume_leaf(contexts[0], &index_dir, leaf_slot[shard], shard)) + .collect(); + let mut reused = 0usize; + for (shard, slot) in resumed.into_iter().enumerate() { + if let Some(slot) = slot { + slots[leaf_slot[shard]] = Some(Arc::new(slot)); + claim_done[shard] = true; + reused += 1; + } else if retired[leaf_slot[shard]] { + claim_done[shard] = true; + } + } + let cached_joins = slots + .iter() + .enumerate() + .filter(|(i, s)| { + s.is_some() && *i != root_slot && !matches!(specs[*i].op, PlanOp::Leaf(_)) + }) + .count(); + say(&format!( + "{shards} claims ({reused} reused from the index, {} retired under cached joins without an indexed proof), {} joins ({cached_joins} cached)", + claim_done.iter().filter(|d| **d).count() - reused, + count - shards + )); + + let (events_tx, events_rx) = mpsc::channel::(); + let prep_queue = WorkQueue::::new(executions); + let item_queue = WorkQueue::::new(cfg.lanes); + let outcome = thread::scope(|scope| -> Result { + let _shutdown = + ShutdownRun { pool: &pool, prep: &prep_queue, items: &item_queue }; + for executor in 0..executions { + let events = events_tx.clone(); + let (ctx, owned, prep, items) = + (contexts[0], &owned, &prep_queue, &item_queue); + scope.spawn(move || { + prepare_loop( + ctx, + executor, + env, + owned, + max_ram_bytes, + prep, + items, + &events, + ) + }); + } + for (worker, &ctx) in contexts.iter().enumerate() { + let events = events_tx.clone(); + let (prepared_run, leaf_slot, index_dir, items, pool) = + (&prepared, &leaf_slot, &index_dir, &item_queue, &pool); + scope.spawn(move || { + prove_loop( + ctx, + worker, + prepared_run, + leaf_slot, + index_dir, + items, + pool, + &events, + ) + }); + } + drop(events_tx); + + let mut claim_queue: VecDeque = + (0..shards).filter(|&s| !claim_done[s]).collect(); + let work_name = |work: Work| match work { + Work::Claim(shard) => { + format!("claim {}", prepared.shards[shard].original_id) + }, + Work::Join(slot) => format!("join {slot}"), + Work::Root => "root".to_string(), + }; + let mut dispatched: FxHashSet = FxHashSet::default(); + let mut claim_records = Vec::new(); + let mut join_records = Vec::new(); + let mut contention_retries = 0usize; + let mut root_dispatched = false; + let mut root_address = None; + let mut failure = None; + let mut to_split = std::collections::BTreeSet::new(); + let mut free_executors = executions; + let mut in_flight = 0usize; + let mut verdict: Option< + thread::ScopedJoinHandle<'_, (Vec, usize)>, + > = None; + let ready_join = |slots: &[Option>], + dispatched: &FxHashSet| { + (0..root_slot).find(|&index| { + !retired[index] + && slots[index].is_none() + && !dispatched.contains(&index) + && match specs[index].op { + PlanOp::Join(l, r) => slots[l].is_some() && slots[r].is_some(), + PlanOp::Leaf(_) => false, + } + }) + }; + loop { + while free_executors > 0 && to_split.is_empty() { + let work = if let Some(slot) = ready_join(&slots, &dispatched) { + Work::Join(slot) + } else if !root_dispatched + && claim_done.iter().all(|d| *d) + && slots[root_left].is_some() + && slots[root_right].is_some() + { + Work::Root + } else if let Some(&shard) = claim_queue.front() { + Work::Claim(shard) + } else { + break; + }; + let Some(reservation) = + pool.try_admit().map_err(|e| format!("record admission: {e:?}"))? + else { + break; + }; + let children = match work { + Work::Claim(_) => Vec::new(), + Work::Join(slot) => { + let PlanOp::Join(l, r) = specs[slot].op else { unreachable!() }; + vec![slots[l].clone().unwrap(), slots[r].clone().unwrap()] + }, + Work::Root => vec![ + slots[root_left].clone().unwrap(), + slots[root_right].clone().unwrap(), + ], + }; + prep_queue + .push( + Prep { work, children, reservation }, + !matches!(work, Work::Claim(_)), + ) + .map_err(|Prep { work, .. }| { + let kind = + if matches!(work, Work::Claim(_)) { "claim" } else { "join" }; + format!("execution queue closed before a {kind} was queued") + })?; + free_executors -= 1; + in_flight += 1; + say(&format!( + "{} dispatched at +{}s", + work_name(work), + started.elapsed().as_secs() + )); + match work { + Work::Claim(_) => { + claim_queue.pop_front(); + }, + Work::Join(slot) => { + dispatched.insert(slot); + }, + Work::Root => { + root_dispatched = true; + if verdict.is_none() { + let leaves: Vec<_> = + (0..shards).map(|s| slots[leaf_slot[s]].clone()).collect(); + let prepared_run = &prepared; + verdict = Some(scope.spawn(move || { + composed_verdict(ixvm, verify_idx, prepared_run, &leaves) + })); + } + }, + } + } + if in_flight == 0 && free_executors == executions { + if !to_split.is_empty() { + break; + } + failure = Some( + "scheduler stalled: nothing runs and nothing can be admitted" + .to_string(), + ); + break; + } + let event = + events_rx.recv().map_err(|e| format!("worker channel closed: {e}"))?; + match event { + Event::ExecutionStarted { executor, work } => say(&format!( + "executor {executor}: {} execution started at +{}s", + work_name(work), + started.elapsed().as_secs(), + )), + Event::Prepared { executor, work, record_bytes, secs } => { + say(&format!( + "executor {executor}: {} executed in {secs:.1}s, record {record_bytes} B ({} GiB) at +{}s", + work_name(work), + format_gib(record_bytes), + started.elapsed().as_secs(), + )); + match work { + Work::Claim(shard) => claim_records.push(( + usize::try_from(prepared.shards[shard].original_id) + .unwrap_or(usize::MAX), + record_bytes, + secs, + )), + Work::Join(slot) => join_records.push((slot, record_bytes, secs)), + Work::Root => join_records.push((root_slot, record_bytes, secs)), + } + }, + Event::PrepAvailable => { + free_executors += 1; + }, + Event::PrepFailed { executor, work, failure: error } => { + free_executors += 1; + in_flight -= 1; + match error { + PrepareFailure::MemoryContention => { + contention_retries += 1; + say(&format!( + "executor {executor}: {} released for memory contention; requeued", + work_name(work) + )); + match work { + Work::Claim(shard) => claim_queue.push_back(shard), + Work::Join(slot) => { + dispatched.remove(&slot); + }, + Work::Root => { + root_dispatched = false; + }, + } + }, + PrepareFailure::OverRecordCap { bytes, cap } => { + if let Work::Claim(shard) = work { + let id = prepared.shards[shard].original_id; + let source = manifest + .shards + .iter() + .find(|s| s.id == id) + .expect("prepared claim belongs to the manifest"); + if source.blocks.len() > 1 { + to_split.insert(id); + say(&format!( + "claim {id}: record needs {bytes} B, above the {cap} B per-record ceiling; draining active work before splitting this claim" + )); + } else { + failure = Some(format!( + "claim {id}: record needs {bytes} B, above the {cap} B per-record ceiling; its single atomic block cannot be split further" + )); + } + } else { + failure = Some(format!( + "{}: aggregation record needs {bytes} B, above the {cap} B per-record ceiling; an aggregation execution cannot be split as an environment claim", + work_name(work) + )); + } + }, + PrepareFailure::Other(error) => { + failure = Some(format!("{}: {error}", work_name(work))) + }, + } + }, + Event::Proving { worker, work } => say(&format!( + "worker {worker}: {} proving started at +{}s", + work_name(work), + started.elapsed().as_secs(), + )), + Event::Proven { worker, work, result } => { + in_flight -= 1; + match (work, result) { + (Work::Claim(shard), Ok(slot)) => { + slots[leaf_slot[shard]] = Some(slot); + claim_done[shard] = true; + say(&format!( + "worker {worker}: claim {} proven at +{}s ({} left)", + prepared.shards[shard].original_id, + started.elapsed().as_secs(), + claim_done.iter().filter(|d| !**d).count() + )); + }, + (Work::Join(slot), Ok(proof)) => { + slots[slot] = Some(proof); + say(&format!( + "worker {worker}: join {slot} published at +{}s", + started.elapsed().as_secs() + )); + }, + (_, Err(error)) => { + failure = Some(format!("{}: {error}", work_name(work))) + }, + (Work::Root, Ok(_)) => { + unreachable!("root reports through RootProven") + }, + } + }, + Event::RootProven { worker, result } => match result { + Ok(address) => { + say(&format!( + "worker {worker}: root proven at +{}s", + started.elapsed().as_secs() + )); + root_address = Some(address); + }, + Err(error) => failure = Some(format!("root: {error}")), + }, + } + if failure.is_some() || root_address.is_some() { + break; + } + } + drop(_shutdown); + if let Some(error) = failure { + return Err(format!( + "{error}; rerun the same command to resume from what was persisted" + )); + } + if !to_split.is_empty() { + return Ok(PassOutcome::Refine(to_split.into_iter().collect())); + } + let root = root_address.ok_or("no root proof")?; + record_summary( + &say, + shards, + Some(host.initial.min(pool.record_limit())), + Some(host.records), + contention_retries, + &claim_records, + &join_records, + ); + let (failures, unproven) = verdict + .ok_or("root proven before composed verdict started")? + .join() + .map_err(|payload| { + format!("composed verdict thread panicked: {}", panic_text(&payload)) + })?; + if failures.is_empty() { + Ok(PassOutcome::Complete { root, unproven }) + } else { + Err(failures.join("; ")) + } + }); + let stats = pool.stats(); + pool_stats.peak_reserved = pool_stats.peak_reserved.max(stats.peak_reserved); + pool_stats.waits += stats.waits; + pool_stats.wait_time += stats.wait_time; + pool_stats.retries += stats.retries; + outcome +} + +/// `AiurSystem.proveLanes`: the whole multi-device run. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_prove_lanes( + ixvm_system: LeanExternal>, + aggr_system: LeanExternal>, + env_handle: LeanExternal>, + manifest_path: LeanString>, + verify_idx: LeanNat>, + aggr_idx: LeanNat>, + lanes: LeanNat>, + max_ram_bytes: LeanNat>, + exec_jobs: LeanNat>, + structural_above: LeanNat>, + cache_fri_bytes: LeanByteArray>, + out_manifest: LeanString>, +) -> LeanExcept { + let cfg = Config { + lanes: lean_unbox_nat_as_usize(lanes.inner()), + max_ram_bytes: lean_unbox_nat_as_usize(max_ram_bytes.inner()), + exec_jobs: lean_unbox_nat_as_usize(exec_jobs.inner()), + structural_above: lean_unbox_nat_as_usize(structural_above.inner()), + cache_fri_bytes: cache_fri_bytes.as_bytes().to_vec(), + out_manifest: (!out_manifest.as_str().is_empty()) + .then(|| PathBuf::from(out_manifest.as_str())), + }; + if cfg.lanes == 0 { + return LeanExcept::error_string("at least one lane is required"); + } + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + run( + &cfg, + ixvm_system.get(), + aggr_system.get(), + &env_handle.get().env, + Path::new(manifest_path.as_str()), + lean_unbox_nat_as_usize(verify_idx.inner()), + lean_unbox_nat_as_usize(aggr_idx.inner()), + ) + })); + match result { + Ok(Ok(root)) => LeanExcept::ok(LeanString::new(&root)), + Ok(Err(error)) => LeanExcept::error_string(&error), + Err(payload) => LeanExcept::error_string(&format!( + "lane scheduler panicked: {}", + panic_text(&payload) + )), + } +} diff --git a/crates/ffi/src/aiur/aggregate/lanes/checkpoint.rs b/crates/ffi/src/aiur/aggregate/lanes/checkpoint.rs new file mode 100644 index 000000000..9b22aaf10 --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes/checkpoint.rs @@ -0,0 +1,65 @@ +use std::{ + fs::{self, OpenOptions}, + io::Write, + path::Path, + sync::atomic::{AtomicU64, Ordering}, +}; + +static NEXT_TEMP: AtomicU64 = AtomicU64::new(0); + +/// A reader sees either the previous complete partition or the next one. +pub(super) fn write_atomic(path: &Path, bytes: &[u8]) -> Result<(), String> { + let parent = path + .parent() + .filter(|p| !p.as_os_str().is_empty()) + .unwrap_or_else(|| Path::new(".")); + fs::create_dir_all(parent) + .map_err(|error| format!("create {}: {error}", parent.display()))?; + let mut name = + path.file_name().ok_or("manifest path has no filename")?.to_os_string(); + name.push(format!( + ".tmp.{}.{}", + std::process::id(), + NEXT_TEMP.fetch_add(1, Ordering::Relaxed) + )); + let temporary = parent.join(name); + let mut file = OpenOptions::new() + .write(true) + .create_new(true) + .open(&temporary) + .map_err(|error| format!("create {}: {error}", temporary.display()))?; + let result = (|| -> std::io::Result<()> { + file.write_all(bytes)?; + file.sync_all()?; + fs::rename(&temporary, path)?; + Ok(()) + })(); + if result.is_err() { + let _ = fs::remove_file(&temporary); + } + result.map_err(|error| format!("write manifest {}: {error}", path.display())) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn replacement_is_complete_and_failed_writes_leave_no_temporary() { + let dir = std::env::temp_dir().join(format!( + "ix-refined-manifest-{}-{}", + std::process::id(), + NEXT_TEMP.fetch_add(1, Ordering::Relaxed) + )); + let path = dir.join("partition.ixes"); + write_atomic(&path, b"first partition").unwrap(); + write_atomic(&path, b"refined partition").unwrap(); + assert_eq!(fs::read(&path).unwrap(), b"refined partition"); + let directory_target = dir.join("directory"); + fs::create_dir(&directory_target).unwrap(); + assert!(write_atomic(&directory_target, b"invalid target").is_err()); + assert!(directory_target.is_dir()); + assert_eq!(fs::read_dir(&dir).unwrap().count(), 2); + fs::remove_dir_all(dir).unwrap(); + } +} diff --git a/crates/ffi/src/aiur/aggregate/lanes/limits.rs b/crates/ffi/src/aiur/aggregate/lanes/limits.rs new file mode 100644 index 000000000..0003e505c --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes/limits.rs @@ -0,0 +1,140 @@ +use std::{ + fs, + path::{Path, PathBuf}, +}; + +pub(super) struct HostBudget { + pub limit: usize, + pub records: usize, + pub workspace: usize, + pub headroom: usize, + pub initial: usize, +} + +impl HostBudget { + pub(super) fn new( + lanes: usize, + executions: usize, + per_lane: usize, + detected: Option, + ceiling: Option, + cells: usize, + ) -> Result { + if lanes == 0 || executions == 0 || cells == 0 { + return Err( + "lanes, execution threads and trace-cell budget must be positive" + .into(), + ); + } + let requested = if per_lane == 0 { + detected.ok_or("cannot detect host memory; specify --max-ram per GPU")? + } else { + per_lane.checked_mul(lanes).ok_or("process host budget overflow")? + }; + let limit = ceiling.map_or(requested, |ceiling| requested.min(ceiling)); + let workspace = cells + .checked_mul(16) + .and_then(|n| n.checked_add(256 << 20)) + .and_then(|n| n.checked_mul(43)) + .map(|n| n.div_ceil(40)) + .ok_or("prover workspace budget overflow")?; + let headroom = limit / 10; + let reserved = workspace + .checked_mul(lanes) + .and_then(|n| n.checked_add(headroom)) + .ok_or("process workspace budget overflow")?; + let records = limit.checked_sub(reserved) + .ok_or("host budget cannot hold the GPU workers' workspace; raise --max-ram or lower AIUR_TRACE_SHARD_MAX_CELLS")?; + let slots = lanes + .checked_mul(2) + .and_then(|n| n.checked_add(executions)) + .ok_or("record admission count overflow")?; + let initial = records / slots; + if initial == 0 { + return Err("no host capacity remains for execution records".into()); + } + Ok(Self { limit, records, workspace, headroom, initial }) + } +} + +fn memory_limit_at(mount: &Path, group: &Path) -> Option { + let mut limit = None; + for path in group.ancestors().take_while(|path| path.starts_with(mount)) { + if let Some(bytes) = fs::read_to_string(path.join("memory.max")) + .ok() + .and_then(|s| s.trim().parse::().ok()) + { + limit = Some(limit.map_or(bytes, |old: usize| old.min(bytes))); + } + } + limit +} + +/// The tightest visible cgroup-v2 ancestor limit, also respecting a +/// cgroup namespace whose mount starts below the hierarchy root. +pub(super) fn cgroup_memory_limit() -> Option { + let membership = fs::read_to_string("/proc/self/cgroup").ok()?; + let group = membership.lines().find_map(|line| line.strip_prefix("0::"))?; + let mounts = fs::read_to_string("/proc/self/mountinfo").ok()?; + let mut limit = None; + for line in mounts.lines() { + let Some((fields, _)) = line.split_once(" - cgroup2 ") else { continue }; + let fields: Vec<_> = fields.split_whitespace().collect(); + let (Some(root), Some(mount)) = (fields.get(3), fields.get(4)) else { + continue; + }; + let mount = PathBuf::from(mount.replace("\\040", " ")); + let root = PathBuf::from(root.replace("\\040", " ")); + let relative = Path::new(group).strip_prefix(&root).ok()?; + if let Some(bytes) = memory_limit_at(&mount, &mount.join(relative)) { + limit = Some(limit.map_or(bytes, |old: usize| old.min(bytes))); + } + } + limit +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn per_lane_values_expand_once_and_auto_detection_is_global() { + let gib = 1usize << 30; + let explicit = + HostBudget::new(4, 12, 230 * gib, None, Some(920 * gib), 1_500_000_000) + .unwrap(); + assert_eq!(explicit.limit, 920 * gib); + assert_eq!( + explicit.records + explicit.workspace * 4 + explicit.headroom, + explicit.limit + ); + assert_eq!(explicit.initial, explicit.records / 20); + let auto = HostBudget::new( + 4, + 12, + 0, + Some(800 * gib), + Some(700 * gib), + 1_500_000_000, + ) + .unwrap(); + assert_eq!(auto.limit, 700 * gib); + assert!(HostBudget::new(4, 12, usize::MAX, None, None, 1).is_err()); + assert!(HostBudget::new(4, 12, 1, None, None, 1).is_err()); + } + + #[test] + fn cgroup_parent_limit_applies_when_leaf_is_unlimited() { + let mount = std::env::temp_dir() + .join(format!("ix-record-cgroup-{}", std::process::id())); + let group = mount.join("parent/leaf"); + fs::create_dir_all(&group).unwrap(); + fs::write(mount.join("memory.max"), "1000\n").unwrap(); + fs::write(mount.join("parent/memory.max"), "800\n").unwrap(); + fs::write(group.join("memory.max"), "max\n").unwrap(); + assert_eq!(memory_limit_at(&mount, &group), Some(800)); + fs::write(group.join("memory.max"), "600\n").unwrap(); + assert_eq!(memory_limit_at(&mount, &group), Some(600)); + fs::remove_dir_all(mount).unwrap(); + } +} diff --git a/crates/ffi/src/aiur/aggregate/lanes/queue.rs b/crates/ffi/src/aiur/aggregate/lanes/queue.rs new file mode 100644 index 000000000..4f8b3eb89 --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes/queue.rs @@ -0,0 +1,124 @@ +use std::collections::VecDeque; +use std::sync::{Condvar, Mutex}; + +struct State { + priority: VecDeque, + ordinary: VecDeque, + closed: bool, +} + +/// Bounded ownership transfer with ready joins ahead of claims. +pub(super) struct WorkQueue { + capacity: usize, + state: Mutex>, + changed: Condvar, +} + +impl WorkQueue { + pub(super) fn new(capacity: usize) -> Self { + assert!(capacity > 0); + Self { + capacity, + state: Mutex::new(State { + priority: VecDeque::new(), + ordinary: VecDeque::new(), + closed: false, + }), + changed: Condvar::new(), + } + } + + pub(super) fn push(&self, item: T, priority: bool) -> Result<(), T> { + let mut state = self.state.lock().unwrap(); + while !state.closed + && state.priority.len() + state.ordinary.len() == self.capacity + { + state = self.changed.wait(state).unwrap(); + } + if state.closed { + return Err(item); + } + if priority { + state.priority.push_back(item); + } else { + state.ordinary.push_back(item); + } + self.changed.notify_all(); + Ok(()) + } + + pub(super) fn pop(&self) -> Option { + let mut state = self.state.lock().unwrap(); + loop { + if state.closed { + return None; + } + if let Some(item) = + state.priority.pop_front().or_else(|| state.ordinary.pop_front()) + { + self.changed.notify_all(); + return Some(item); + } + state = self.changed.wait(state).unwrap(); + } + } + + pub(super) fn close(&self) { + let mut state = self.state.lock().unwrap(); + state.closed = true; + let priority = std::mem::take(&mut state.priority); + let ordinary = std::mem::take(&mut state.ordinary); + self.changed.notify_all(); + drop(state); + drop((priority, ordinary)); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::{ + sync::{Arc, mpsc}, + thread, + time::Duration, + }; + + #[test] + fn ready_joins_precede_claims_without_reordering_peers() { + let queue = WorkQueue::new(4); + queue.push(1, false).unwrap(); + queue.push(2, true).unwrap(); + queue.push(3, true).unwrap(); + queue.push(4, false).unwrap(); + assert_eq!( + (queue.pop(), queue.pop(), queue.pop(), queue.pop()), + (Some(2), Some(3), Some(1), Some(4)) + ); + } + + #[test] + fn closing_releases_items_and_wakes_producers_and_consumers() { + let full = Arc::new(WorkQueue::new(1)); + let stored = Arc::new(()); + full.push(Arc::clone(&stored), false).unwrap(); + let producer_queue = Arc::clone(&full); + let (tx, rx) = mpsc::channel(); + let producer = thread::spawn(move || { + tx.send(producer_queue.push(Arc::new(()), false).is_err()).unwrap(); + }); + full.close(); + assert_eq!(Arc::strong_count(&stored), 1); + assert!(rx.recv_timeout(Duration::from_secs(3)).unwrap()); + producer.join().unwrap(); + assert!(full.pop().is_none()); + + let empty = Arc::new(WorkQueue::::new(1)); + let consumer_queue = Arc::clone(&empty); + let (tx, rx) = mpsc::channel(); + let consumer = + thread::spawn(move || tx.send(consumer_queue.pop()).unwrap()); + empty.close(); + assert_eq!(rx.recv_timeout(Duration::from_secs(3)).unwrap(), None); + consumer.join().unwrap(); + } +} diff --git a/crates/ffi/src/aiur/aggregate/plan.rs b/crates/ffi/src/aiur/aggregate/plan.rs index b248b128f..109c06232 100644 --- a/crates/ffi/src/aiur/aggregate/plan.rs +++ b/crates/ffi/src/aiur/aggregate/plan.rs @@ -260,3 +260,81 @@ pub(super) fn plan_replay( || children.iter().any(|index| specs[*index].kind == ChildKind::Ixvm); Ok(ReplayPlan { children, needs_input_proofs }) } + +/// Leaves under every slot of a post-order plan. +pub(super) fn leaves_under(ops: &[PlanOp]) -> Vec { + let mut leaves = vec![0usize; ops.len()]; + for (index, op) in ops.iter().enumerate() { + leaves[index] = match *op { + PlanOp::Leaf(_) => 1, + PlanOp::Join(left, right) => leaves[left] + leaves[right], + }; + } + leaves +} + +/// Splits frontier node `at` into its children when it is a join. A child +/// that is a raw leaf becomes a one-leaf subtree: its claim proof is its +/// published proof, and the join above it verifies that raw leaf beside +/// its cached sibling. Returns whether it split. +fn split_frontier( + ops: &[PlanOp], + frontier: &mut Vec, + at: usize, +) -> bool { + let PlanOp::Join(left, right) = ops[frontier[at]] else { + return false; + }; + frontier.swap_remove(at); + frontier.push(left); + frontier.push(right); + true +} + +/// The plan cut into subtrees for dynamic scheduling: the tree is split from +/// the root while any frontier node holds more leaves than +/// `ceil(leaves / subtrees)`. Returns the frontier (the subtrees, post-order; +/// a subtree may be a single raw leaf) and every join above it (post-order, +/// so each appears after its children). A subtree of several leaves is +/// proven as one `--subtree` task once its leaves' claims exist; a +/// one-leaf subtree is published by its claim proof alone; an upper join +/// once both children are published; whichever device is free takes the +/// next ready task, so no packing is decided ahead of time. +pub(super) fn subtree_plan( + ops: &[PlanOp], + max_leaves: usize, +) -> (Vec, Vec) { + let Some(root) = ops.len().checked_sub(1) else { + return (Vec::new(), Vec::new()); + }; + let leaves = leaves_under(ops); + let target = max_leaves.max(1); + let mut frontier = vec![root]; + while let Some(at) = (0..frontier.len()) + .filter(|&at| leaves[frontier[at]] > target) + .max_by_key(|&at| leaves[frontier[at]]) + { + if !split_frontier(ops, &mut frontier, at) { + break; + } + } + frontier.sort_unstable(); + // Everything above the frontier: the ancestors of frontier nodes. + let mut above = vec![false; ops.len()]; + let mut in_frontier = vec![false; ops.len()]; + for &slot in &frontier { + in_frontier[slot] = true; + } + for index in 0..ops.len() { + if let PlanOp::Join(left, right) = ops[index] + && (in_frontier[left] + || in_frontier[right] + || above[left] + || above[right]) + { + above[index] = true; + } + } + let upper: Vec = (0..ops.len()).filter(|&i| above[i]).collect(); + (frontier, upper) +} diff --git a/crates/ffi/src/aiur/aggregate/tests.rs b/crates/ffi/src/aiur/aggregate/tests.rs index 1c7f24890..37027be5b 100644 --- a/crates/ffi/src/aiur/aggregate/tests.rs +++ b/crates/ffi/src/aiur/aggregate/tests.rs @@ -15,6 +15,7 @@ use std::sync::Arc; use ixon::{Axiom, Expr}; +mod plan; mod prepare; mod scheduler; mod store; diff --git a/crates/ffi/src/aiur/aggregate/tests/plan.rs b/crates/ffi/src/aiur/aggregate/tests/plan.rs new file mode 100644 index 000000000..5451abd54 --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/tests/plan.rs @@ -0,0 +1,93 @@ +use super::super::plan::{PlanOp, leaves_under, subtree_plan}; + +/// A post-order plan from a nested leaf-count shape: `(a, b)` joins the +/// plans of `a` and `b`; a number is that many balanced leaves. +fn plan_of(shape: &str) -> Vec { + fn go(chars: &[u8], at: &mut usize, out: &mut Vec) -> usize { + if chars[*at] == b'(' { + *at += 1; + let left = go(chars, at, out); + assert_eq!(chars[*at], b','); + *at += 1; + let right = go(chars, at, out); + assert_eq!(chars[*at], b')'); + *at += 1; + out.push(PlanOp::Join(left, right)); + } else { + let start = *at; + while *at < chars.len() && chars[*at].is_ascii_digit() { + *at += 1; + } + let count: usize = + std::str::from_utf8(&chars[start..*at]).unwrap().parse().unwrap(); + let ids: Vec = (0..u32::try_from(count).unwrap()).collect(); + fn balanced(ids: &[u32], out: &mut Vec) -> usize { + if ids.len() == 1 { + out.push(PlanOp::Leaf(ids[0] as usize)); + } else { + let (l, r) = ids.split_at(ids.len() / 2); + let left = balanced(l, out); + let right = balanced(r, out); + out.push(PlanOp::Join(left, right)); + } + out.len() - 1 + } + balanced(&ids, out); + } + out.len() - 1 + } + let mut out = Vec::new(); + go(shape.as_bytes(), &mut 0, &mut out); + out +} + +#[test] +fn subtree_plan_cuts_to_the_target_and_lists_the_joins_above() { + let sizes = |ops: &[PlanOp], slots: &[usize]| -> Vec { + let leaves = leaves_under(ops); + slots.iter().map(|&s| leaves[s]).collect() + }; + // Balanced: a size of eight keeps the root whole; a size of two cuts + // to the depth-2 nodes, with the two depth-1 joins and the root above. + let ops = plan_of("8"); + let (frontier, upper) = subtree_plan(&ops, 8); + assert_eq!(frontier, vec![ops.len() - 1]); + assert!(upper.is_empty()); + let (frontier, upper) = subtree_plan(&ops, 2); + assert_eq!(sizes(&ops, &frontier), vec![2, 2, 2, 2]); + assert_eq!(upper.len(), 3); + assert_eq!(*upper.last().unwrap(), ops.len() - 1); + // Mathlib's 128-way shape at the top: root = (70, 58), 70 = (38, 32), + // 58 = (32, 26). A size of eight leaves nothing larger than that. + let ops = plan_of("((38,32),(32,26))"); + let (frontier, upper) = subtree_plan(&ops, 8); + let leaves = sizes(&ops, &frontier); + assert_eq!(leaves.iter().sum::(), 128); + assert!(leaves.iter().all(|n| (2..=8).contains(n))); + // Post-order: every upper join comes after its children. + let position = |slot: usize| upper.iter().position(|&s| s == slot); + for &slot in &upper { + let PlanOp::Join(left, right) = ops[slot] else { panic!("join") }; + for child in [left, right] { + if let Some(at) = position(child) { + assert!(at < position(slot).unwrap()); + } else { + assert!(frontier.contains(&child)); + } + } + } + // A lone leaf beside a subtree: the tree (1 + 32) + 16 has 49 leaves; + // a size of four means the 33-leaf node must be cut even though one of + // its children is a raw leaf, which then stands as a one-leaf subtree. + let ops = plan_of("((1,32),16)"); + let (frontier, _) = subtree_plan(&ops, 4); + let leaves = sizes(&ops, &frontier); + assert_eq!(leaves.iter().sum::(), 1 + 32 + 16); + assert!(leaves.iter().all(|&n| n <= 4)); + assert_eq!(leaves.iter().filter(|&&n| n == 1).count(), 1); + // A two-leaf tree at size one: two one-leaf subtrees under the root join. + let ops = plan_of("2"); + let (frontier, upper) = subtree_plan(&ops, 1); + assert_eq!(sizes(&ops, &frontier), vec![1, 1]); + assert_eq!(upper, vec![ops.len() - 1]); +} diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 7894a7605..61a74ba8a 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -1121,6 +1121,7 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( retention: LeanNat>, ) -> LeanExcept { ffi_catch_unwind_except("AiurSystem.shardProveWithEnv", || { + crate::profile::init(); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); let retention = match lean_unbox_nat_as_usize(retention.inner()) { @@ -2304,6 +2305,7 @@ pub(super) fn ffi_catch_unwind( context: &str, f: impl FnOnce() -> LeanOwned, ) -> LeanExcept { + crate::profile::init(); match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) { Ok(value) => LeanExcept::ok(value), Err(payload) => { @@ -2321,6 +2323,7 @@ fn ffi_catch_unwind_except( context: &str, f: impl FnOnce() -> LeanExcept, ) -> LeanExcept { + crate::profile::init(); match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) { Ok(result) => result, Err(payload) => { diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 3a28e05ef..3a1bc4ffd 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -2461,7 +2461,7 @@ pub extern "C" fn rs_shard_env_static( requested_shards } else if cfg!(feature = "cuda") { // The trace-shard prover: seed against one execution's record share, - // computed as `ix prove --exec-jobs` computes it. + // computed as `ix prove --lanes` computes it. let cells = crate::aiur::protocol::trace_shard_max_cells(); let budget = usize::try_from(ram_gib << 30).unwrap_or(usize::MAX); let share = diff --git a/crates/ffi/src/lib.rs b/crates/ffi/src/lib.rs index 93157799b..4ffe0dbfd 100644 --- a/crates/ffi/src/lib.rs +++ b/crates/ffi/src/lib.rs @@ -20,6 +20,7 @@ pub mod lean_env; not(all(target_os = "macos", target_arch = "aarch64")) ))] pub mod lean_iroh; +mod profile; pub mod texray; pub mod unsigned; diff --git a/crates/ffi/src/profile.rs b/crates/ffi/src/profile.rs new file mode 100644 index 000000000..8cbc48e80 --- /dev/null +++ b/crates/ffi/src/profile.rs @@ -0,0 +1,160 @@ +//! Opt-in lightweight summaries and timestamped profiling events. + +use std::{ + fs::{File, OpenOptions}, + io::Write, + sync::{Arc, Mutex, Once, OnceLock}, + time::{SystemTime, UNIX_EPOCH}, +}; + +use serde_json::{Map, Value, json}; +use tracing::{Subscriber, field::Visit, span}; +use tracing_subscriber::{ + Layer, filter::filter_fn, layer::Context, prelude::*, +}; + +mod metrics; + +type Sink = Arc>; +static SINK: OnceLock> = OnceLock::new(); +static INIT: Once = Once::new(); + +thread_local! { + static TID: String = std::fs::read_link("/proc/thread-self") + .ok() + .and_then(|path| path.file_name().map(|name| name.to_string_lossy().into_owned())) + .unwrap_or_else(|| format!("{:?}", std::thread::current().id())); +} + +struct Fields(Map); + +impl Visit for Fields { + fn record_debug( + &mut self, + field: &tracing::field::Field, + value: &dyn std::fmt::Debug, + ) { + self.0.insert(field.name().into(), json!(format!("{value:?}"))); + } +} + +struct Timeline(Sink); + +impl Timeline { + fn emit(&self, mut event: Value) { + event["ts_ns"] = json!( + u64::try_from( + SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos() + ) + .unwrap_or(u64::MAX) + ); + event["tid"] = TID.with(|tid| json!(tid)); + event["pid"] = json!(std::process::id()); + let mut line = serde_json::to_vec(&event).expect("span event is JSON"); + line.push(b'\n'); + // Write through: the global subscriber outlives Rust's ordinary drop scope. + if let Err(error) = self.0.lock().unwrap().write_all(&line) { + eprintln!("[profile] span write failed: {error}"); + } + } +} + +impl Layer for Timeline { + fn on_new_span( + &self, + attrs: &span::Attributes<'_>, + id: &span::Id, + ctx: Context<'_, S>, + ) { + let mut fields = Fields(Map::new()); + attrs.record(&mut fields); + let parent = attrs.parent().cloned().or_else(|| { + attrs.is_contextual().then(|| ctx.current_span().id().cloned()).flatten() + }); + self.emit(json!({"event": "new", "id": id.into_u64(), + "parent": parent.map(|id| id.into_u64()), "name": attrs.metadata().name(), + "target": attrs.metadata().target(), "fields": fields.0})); + } + + fn on_record( + &self, + id: &span::Id, + values: &span::Record<'_>, + _: Context<'_, S>, + ) { + let mut fields = Fields(Map::new()); + values.record(&mut fields); + self.emit( + json!({"event": "record", "id": id.into_u64(), "fields": fields.0}), + ); + } + + fn on_enter(&self, id: &span::Id, _: Context<'_, S>) { + self.emit(json!({"event": "enter", "id": id.into_u64()})); + } + + fn on_exit(&self, id: &span::Id, _: Context<'_, S>) { + self.emit(json!({"event": "exit", "id": id.into_u64()})); + } + + fn on_close(&self, id: span::Id, _: Context<'_, S>) { + self.emit(json!({"event": "close", "id": id.into_u64()})); + } +} + +pub(crate) fn layer() -> Option> +where + S: Subscriber + for<'span> tracing_subscriber::registry::LookupSpan<'span>, +{ + let sink = SINK.get_or_init(|| { + let path = std::env::var_os("AIUR_PROFILE")?; + match OpenOptions::new().write(true).create_new(true).open(&path) { + Ok(file) => Some(Arc::new(Mutex::new(file))), + Err(error) => { + eprintln!("[profile] cannot create {path:?}: {error}"); + None + }, + } + }); + sink.as_ref().map(|sink| { + Timeline(sink.clone()).with_filter(filter_fn(|meta| { + meta.is_span() + && ["aiur/", "stark/", "cuda/"] + .iter() + .any(|p| meta.name().starts_with(p)) + })) + }) +} + +pub(crate) fn init() { + if std::env::var_os("AIUR_PROFILE").is_none() + && std::env::var_os("AIUR_METRICS").is_none() + && std::env::var_os("RUST_LOG").is_none() + { + return; + } + INIT.call_once(|| { + let mut layers = Vec::new(); + if let Some(timeline) = layer::() { + layers.push(timeline.boxed()); + } + if let Some(metrics) = metrics::Metrics::from_env() { + layers.push(metrics.with_filter(filter_fn(metrics::selected)).boxed()); + } + if let Ok(filter) = std::env::var("RUST_LOG") { + layers.push( + tracing_subscriber::fmt::layer() + .with_ansi(false) + .with_writer(std::io::stderr) + .with_filter(tracing_subscriber::EnvFilter::new(filter)) + .boxed(), + ); + } + if layers.is_empty() { + return; + } + if let Err(error) = tracing_subscriber::registry().with(layers).try_init() { + eprintln!("[profile] cannot install subscriber: {error}"); + } + }); +} diff --git a/crates/ffi/src/profile/metrics.rs b/crates/ffi/src/profile/metrics.rs new file mode 100644 index 000000000..cce12e5ae --- /dev/null +++ b/crates/ffi/src/profile/metrics.rs @@ -0,0 +1,531 @@ +//! Aggregated host timings and counters, with one record per proving boundary. + +use std::{ + collections::{BTreeMap, HashMap}, + fs::{File, OpenOptions}, + io::Write, + sync::{ + Arc, Mutex, + atomic::{AtomicU64, Ordering}, + }, + thread::ThreadId, + time::{Instant, SystemTime, UNIX_EPOCH}, +}; + +use serde_json::{Map, Value, json}; +use tracing::{ + Event, Subscriber, + field::{Field, Visit}, + span, +}; +use tracing_subscriber::{Layer, layer::Context, registry::LookupSpan}; + +const TARGET: &str = "prover_metrics"; +static NEXT_ID: AtomicU64 = AtomicU64::new(1); + +pub(super) fn selected(metadata: &tracing::Metadata<'_>) -> bool { + if metadata.is_event() { + return metadata.target() == TARGET; + } + matches!( + metadata.name(), + "aiur/metrics_unit" + | "aiur/prove_planned" + | "aiur/prove_records" + | "aiur/witness" + | "stark/batch_round_1" + | "stark/batch_round_2" + | "aiur/cpu_circuit" + | "aiur/codegen_seeds" + | "aiur/codegen_filter" + | "aiur/codegen_pack" + | "aiur/codegen_widen" + | "aiur/codegen_concat" + | "aiur/codegen_memory_seeds" + | "stark/stage1_commit" + | "stark/commit_merkle" + | "stark/lookup_construction" + | "stark/quotient" + | "stark/fri_open" + | "stark/fri_prepare" + | "stark/fri_interpolate" + | "stark/fri_reduce" + | "stark/fri_prove" + | "stark/fri_queries" + | "cuda/lde" + | "cuda/lookup_lde" + | "cuda/quotient_lde" + | "cuda/dft_batch" + | "cuda/coset_lde_batch" + ) +} + +#[derive(Default)] +struct Fields(Map); + +impl Visit for Fields { + fn record_u64(&mut self, f: &Field, v: u64) { + self.0.insert(f.name().into(), v.into()); + } + fn record_i64(&mut self, f: &Field, v: i64) { + self.0.insert(f.name().into(), v.into()); + } + fn record_bool(&mut self, f: &Field, v: bool) { + self.0.insert(f.name().into(), v.into()); + } + fn record_str(&mut self, f: &Field, v: &str) { + self.0.insert(f.name().into(), v.into()); + } + fn record_debug(&mut self, f: &Field, v: &dyn std::fmt::Debug) { + let value = format!("{v:?}"); + self.0.insert( + f.name().into(), + value.parse::().map_or_else(|_| value.into(), Value::from), + ); + } +} + +#[derive(Default)] +struct Total { + count: u64, + elapsed_sum_ns: u64, + counters: BTreeMap, + last: BTreeMap, +} + +#[derive(Default)] +struct Aggregate(BTreeMap<(String, String), Total>); + +impl Aggregate { + fn add( + &mut self, + name: &str, + labels: &Map, + elapsed: u64, + counters: BTreeMap, + last: BTreeMap, + ) { + let key = + (name.into(), serde_json::to_string(labels).expect("metric labels")); + let total = self.0.entry(key).or_default(); + total.count += 1; + total.elapsed_sum_ns = total.elapsed_sum_ns.saturating_add(elapsed); + for (key, value) in counters { + let count = total.counters.entry(key).or_default(); + *count = count.saturating_add(value); + } + total.last.extend(last); + } + + fn rows(&self) -> Vec { + self.0.iter().map(|((name, labels), total)| json!({ + "name": name, "labels": serde_json::from_str::(labels).expect("metric labels"), + "count": total.count, "elapsed_sum_ns": total.elapsed_sum_ns, + "counters": total.counters, "last": total.last, + })).collect() + } +} + +struct Bucket { + id: u64, + parent: Option, + identity: Map, + started: Instant, + totals: Mutex, +} + +struct State { + bucket: Arc, + name: &'static str, + fields: Map, + boundary: bool, + // A carrier span can be entered on both the producer and consumer threads. + // Count each thread's outermost entry; these durations are sums, not unions. + active: HashMap, + elapsed: u64, +} + +pub(super) struct Metrics { + output: Mutex, +} + +impl Metrics { + pub(super) fn from_env() -> Option { + let path = std::env::var_os("AIUR_METRICS")?; + match OpenOptions::new().write(true).create_new(true).open(&path) { + Ok(file) => { + let layer = Self { output: Mutex::new(file) }; + let controls: BTreeMap<_, _> = [ + "AIUR_GPU_TRACE", + "AIUR_TRACE_ONLY_LOOKUPS", + "AIUR_GPU_TRACE_MEMORY", + "AIUR_GPU_SEED_CACHE_BYTES", + "AIUR_MAX_PIECE_LOG_HEIGHT", + "AIUR_TRACE_SHARD_MAX_CELLS", + "MULTI_STARK_CUDA_MIN_FREE_BYTES", + "CUDA_VISIBLE_DEVICES", + "RAYON_NUM_THREADS", + "AIUR_METRICS_RUN_ID", + ] + .into_iter() + .filter_map(|name| std::env::var(name).ok().map(|v| (name, v))) + .collect(); + layer.write(&json!({"type": "metadata", "schema": 1, + "pid": std::process::id(), "controls": controls, + "executable": std::env::current_exe().ok(), + "timing": "host elapsed sums; overlapping and nested durations are not additive wall time", + "device_counters": "cumulative per process and device; never attribute snapshot deltas to concurrent proofs"})); + Some(layer) + }, + Err(error) => { + eprintln!("[metrics] cannot create {path:?}: {error}"); + None + }, + } + } + + fn write(&self, value: &Value) { + let mut bytes = serde_json::to_vec(value).expect("metric record"); + bytes.push(b'\n'); + if let Err(error) = self.output.lock().unwrap().write_all(&bytes) { + eprintln!("[metrics] write failed: {error}"); + } + } +} + +impl LookupSpan<'a>> Layer for Metrics { + fn on_new_span( + &self, + attrs: &span::Attributes<'_>, + id: &span::Id, + ctx: Context<'_, S>, + ) { + let Some(span) = ctx.span(id) else { + return; + }; + let parent = span.parent().and_then(|p| { + p.scope().find_map(|p| { + p.extensions().get::().map(|s| Arc::clone(&s.bucket)) + }) + }); + let mut fields = Fields::default(); + attrs.record(&mut fields); + let name = attrs.metadata().name(); + let boundary = matches!( + name, + "aiur/metrics_unit" + | "aiur/prove_planned" + | "aiur/prove_records" + | "aiur/witness" + | "stark/batch_round_1" + | "stark/batch_round_2" + ); + let bucket = if boundary { + let mut identity = + parent.as_ref().map_or_else(Map::new, |p| p.identity.clone()); + identity.extend(fields.0.clone()); + if name == "stark/batch_round_1" { + identity.insert("round".into(), 1.into()); + } + if name == "stark/batch_round_2" { + identity.insert("round".into(), 2.into()); + } + Arc::new(Bucket { + id: NEXT_ID.fetch_add(1, Ordering::Relaxed), + parent: parent.as_ref().map(|p| p.id), + identity, + started: Instant::now(), + totals: Mutex::new(Aggregate::default()), + }) + } else { + let Some(parent) = parent else { + return; + }; + parent + }; + span.extensions_mut().insert(State { + bucket, + name, + fields: fields.0, + boundary, + active: HashMap::new(), + elapsed: 0, + }); + } + + fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) { + let Some(span) = ctx.span(id) else { + return; + }; + let mut ext = span.extensions_mut(); + let Some(state) = ext.get_mut::() else { + return; + }; + let entry = state + .active + .entry(std::thread::current().id()) + .or_insert_with(|| (0, Instant::now())); + entry.0 += 1; + } + + fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) { + let Some(span) = ctx.span(id) else { + return; + }; + let mut ext = span.extensions_mut(); + let Some(state) = ext.get_mut::() else { + return; + }; + let tid = std::thread::current().id(); + if let Some((depth, started)) = state.active.get_mut(&tid) { + *depth -= 1; + if *depth == 0 { + state.elapsed = state.elapsed.saturating_add( + u64::try_from(started.elapsed().as_nanos()).unwrap_or(u64::MAX), + ); + state.active.remove(&tid); + } + } + } + + fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) { + let Some(span) = ctx.event_span(event) else { + return; + }; + let bucket = span.scope().find_map(|p| { + p.extensions().get::().map(|s| Arc::clone(&s.bucket)) + }); + let Some(bucket) = bucket else { + return; + }; + let mut fields = Fields::default(); + event.record(&mut fields); + let name = fields + .0 + .remove("metric") + .and_then(|v| v.as_str().map(str::to_owned)) + .unwrap_or_else(|| "counter".into()); + let mut counters = BTreeMap::new(); + let mut last = BTreeMap::new(); + let mut labels = Map::new(); + let snapshot = fields.0.get("scope").and_then(Value::as_str) + == Some("process_device_cumulative") + || name == "lookup_admission"; + for (key, value) in fields.0 { + let label = matches!( + key.as_str(), + "device" + | "circuit" + | "function" + | "job" + | "height" + | "width" + | "added_bits" + | "log_height" + | "width_bucket" + | "backend" + ); + if !label && let Some(value) = value.as_u64() { + if snapshot || key == "cached_bytes" { + last.insert(key, value); + } else { + counters.insert(key, value); + } + } else { + labels.insert(key, value); + } + } + bucket.totals.lock().unwrap().add(&name, &labels, 0, counters, last); + } + + fn on_close(&self, id: span::Id, ctx: Context<'_, S>) { + let Some(span) = ctx.span(&id) else { + return; + }; + let Some(state) = span.extensions_mut().remove::() else { + return; + }; + if state.boundary { + let mut record = json!({"type": "summary", "schema": 1, "pid": std::process::id(), + "id": state.bucket.id, "parent": state.bucket.parent, + "boundary": state.name, "identity": state.bucket.identity, + "wall_elapsed_ns": u64::try_from(state.bucket.started.elapsed().as_nanos()).unwrap_or(u64::MAX), + "elapsed_sum_ns": state.elapsed, "incomplete": std::thread::panicking(), + "timestamp_ns": u64::try_from(SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_nanos()).unwrap_or(u64::MAX), + "metrics": state.bucket.totals.lock().unwrap().rows()}); + #[cfg(feature = "cuda-trace-codegen")] + { + record["seed_cache_device_snapshot"] = + aiur::trace_codegen::cuda::seed_cache_snapshot() + .into_iter() + .map(|(device, bytes, refused)| { + json!({"device": device, + "retained_bytes": bytes, "refused_requests": refused}) + }) + .collect::>() + .into(); + } + record["process_rss_bytes"] = + std::fs::read_to_string("/proc/self/status") + .ok() + .and_then(|s| { + s.lines().find_map(|line| { + line + .strip_prefix("VmRSS:") + .and_then(|v| v.split_whitespace().next()) + .and_then(|v| v.parse::().ok()) + }) + }) + .map(|kib| kib.saturating_mul(1024)) + .into(); + self.write(&record); + } else { + state.bucket.totals.lock().unwrap().add( + state.name, + &state.fields, + state.elapsed, + BTreeMap::new(), + BTreeMap::new(), + ); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use tracing_subscriber::{filter::filter_fn, prelude::*}; + + fn capture(run: impl FnOnce()) -> Vec { + let path = std::env::temp_dir().join(format!( + "ix-metrics-{}-{}.jsonl", + std::process::id(), + NEXT_ID.fetch_add(1, Ordering::Relaxed) + )); + let file = + OpenOptions::new().create_new(true).write(true).open(&path).unwrap(); + let subscriber = tracing_subscriber::registry().with( + Metrics { output: Mutex::new(file) }.with_filter(filter_fn(selected)), + ); + tracing::subscriber::with_default(subscriber, run); + let result = std::fs::read_to_string(&path) + .unwrap() + .lines() + .map(|line| serde_json::from_str(line).unwrap()) + .collect(); + std::fs::remove_file(path).unwrap(); + result + } + + #[test] + fn counters_are_bounded_by_piece_and_fine_events_are_disabled() { + let records = capture(|| { + let _proof = + tracing::info_span!("aiur/prove_planned", pieces = 2).entered(); + assert!( + tracing::info_span!("aiur/codegen_device_rows", rows = 65536) + .is_disabled() + ); + for shard in 0..2 { + let _piece = + tracing::info_span!("stark/batch_round_2", shard).entered(); + for _ in 0..3 { + let _op = + tracing::info_span!("cuda/lde", height = 16, width = 2).entered(); + tracing::info!(target: TARGET, metric = "seed_cache", device = 0, action = "upload", bytes = 64u64); + } + } + }); + assert_eq!(records.len(), 3); + for (shard, record) in records[..2].iter().enumerate() { + assert_eq!(record["identity"]["shard"], shard); + assert_eq!(record["identity"]["round"], 2); + assert_eq!(record["parent"], records[2]["id"]); + let metrics = record["metrics"].as_array().unwrap(); + let cache = metrics.iter().find(|m| m["name"] == "seed_cache").unwrap(); + assert_eq!(cache["count"], 3); + assert_eq!(cache["counters"]["bytes"], 192); + let lde = metrics.iter().find(|m| m["name"] == "cuda/lde").unwrap(); + assert_eq!(lde["count"], 3); + } + } + + #[test] + fn concurrent_witnesses_keep_their_own_piece_identity() { + let records = capture(|| { + let _proof = + tracing::info_span!("aiur/prove_planned", pieces = 2).entered(); + let dispatch = tracing::dispatcher::get_default(Clone::clone); + let spans = (0..2) + .map(|shard| tracing::info_span!("aiur/witness", shard, round = 1)) + .collect::>(); + std::thread::scope(|scope| { + for (shard, span) in spans.into_iter().enumerate() { + let dispatch = dispatch.clone(); + scope.spawn(move || { + tracing::dispatcher::with_default(&dispatch, || { + let _entered = span.entered(); + for function in 0..4 { + let _op = + tracing::info_span!("aiur/codegen_pack", function, rows = 8) + .entered(); + tracing::info!(target: TARGET, metric = "seed_pack", function, + rows = 8u64, seed_bytes = (shard + 1) * 64); + } + }) + }); + } + }); + }); + assert_eq!(records.len(), 3); + for record in &records[..2] { + let shard = record["identity"]["shard"].as_u64().unwrap(); + let counts = record["metrics"] + .as_array() + .unwrap() + .iter() + .filter(|m| m["name"] == "seed_pack") + .map(|m| m["counters"]["seed_bytes"].as_u64().unwrap()) + .collect::>(); + assert_eq!(counts, vec![(shard + 1) * 64; 4]); + } + } + + #[test] + fn unwinding_emits_an_incomplete_summary() { + let records = capture(|| { + let result = std::panic::catch_unwind(|| { + let _piece = + tracing::info_span!("stark/batch_round_1", shard = 5).entered(); + tracing::info!(target: TARGET, metric = "trace", rows = 8u64); + panic!("fixture failure"); + }); + assert!(result.is_err()); + }); + assert_eq!(records.len(), 1); + assert_eq!(records[0]["incomplete"], true); + assert_eq!(records[0]["metrics"][0]["counters"]["rows"], 8); + } + + #[test] + fn cumulative_snapshots_and_gauges_are_not_summed() { + let records = capture(|| { + let _piece = + tracing::info_span!("stark/batch_round_2", shard = 0).entered(); + for transforms in [5u64, 8] { + tracing::info!(target: TARGET, metric = "ntt_snapshot", device = 0, + scope = "process_device_cumulative", log_height = 20, transforms); + tracing::info!(target: TARGET, metric = "host_coset", action = "hit", + log_height = 20, cached_bytes = 1024u64); + } + }); + let rows = records[0]["metrics"].as_array().unwrap(); + let ntt = rows.iter().find(|r| r["name"] == "ntt_snapshot").unwrap(); + assert_eq!(ntt["last"]["transforms"], 8); + assert_eq!(ntt["counters"], json!({})); + let coset = rows.iter().find(|r| r["name"] == "host_coset").unwrap(); + assert_eq!(coset["count"], 2); + assert_eq!(coset["last"]["cached_bytes"], 1024); + assert!(records[0]["wall_elapsed_ns"].as_u64().unwrap() > 0); + } +} diff --git a/crates/ffi/src/texray.rs b/crates/ffi/src/texray.rs index f4a76b2b0..28468eb57 100644 --- a/crates/ffi/src/texray.rs +++ b/crates/ffi/src/texray.rs @@ -57,7 +57,10 @@ extern "C" fn rs_texray_init( prefixes.iter().any(|p| name.starts_with(p.as_str())) }); - let _ = Registry::default().with(layer.with_filter(filter)).try_init(); + let _ = Registry::default() + .with(crate::profile::layer()) + .with(layer.with_filter(filter)) + .try_init(); LeanIOResult::ok(LeanOwned::box_usize(0)) } From 9ae4674e512a5e167ae75245c4faed4fcc2e3353 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Thu, 1 Oct 2026 09:43:06 -0400 Subject: [PATCH 3/9] aiur: generate CUDA trace writers from compiled bytecode A trace plan per constrained function, derived from the compiled bytecode: the SSA values each row needs, the seed words an execution records for it, and the column spans it writes. From the plan the compiler emits Rust seed packers and row writers and the matching CUDA row writers, plus a registry the GPU trace runtime binds against after checking the program fingerprint. `ix codegen --trace-bundle` writes the production units for the three programs and `--check` detects stale ones, as the executor check does; `--trace-report` prints the plan inventory. Fixtures and BLAKE3 units for the Rust and CUDA parity tests are generated the same way. The Rust renderer leaves expressions bare where the grammar already delimits them and elides unit return types, which the generated writers need to pass clippy. --- .github/workflows/ci.yml | 1 + Ix/Aiur/Codegen/Rust.lean | 48 +- Ix/Aiur/Stages/TraceCodegen.lean | 391 + Ix/Aiur/Stages/TraceContract.lean | 99 + Ix/Aiur/Stages/TraceCuda.lean | 289 + Ix/Aiur/Stages/TracePlan.lean | 858 ++ Ix/Aiur/Stages/TraceReport.lean | 181 + Ix/Cli/CodegenCmd.lean | 168 +- Tests/Aiur.lean | 1 + Tests/Aiur/TraceCodegen.lean | 172 + Tests/Aiur/TraceFixtures.lean | 43 + Tests/Aiur/TracePlan.lean | 406 + Tests/Main.lean | 1 + crates/aiur/build.rs | 300 + crates/aiur/cuda/generated/blake3.cu | 1649 ++++ crates/aiur/cuda/generated/fixtures.cu | 3108 ++++++ .../aiur/cuda/generated/production/ix_aggr.cu | 2801 ++++++ crates/aiur/cuda/generated/production/ixvm.cu | 8608 +++++++++++++++++ .../cuda/generated/production/multi_stark.cu | 6707 +++++++++++++ .../generated/production/trace-manifest.json | 104 + crates/aiur/cuda/trace-manifest.json | 70 + crates/aiur/src/trace_codegen.rs | 818 ++ crates/aiur/src/trace_codegen/contract.rs | 225 + crates/aiur/src/trace_codegen/cuda.rs | 946 ++ .../src/trace_codegen/programs/ix_aggr.rs | 1929 ++++ .../trace_codegen/programs/ix_aggr_cuda.rs | 325 + .../aiur/src/trace_codegen/programs/ixvm.rs | 5313 ++++++++++ .../src/trace_codegen/programs/ixvm_cuda.rs | 861 ++ crates/aiur/src/trace_codegen/programs/mod.rs | 183 + .../src/trace_codegen/programs/multi_stark.rs | 1647 ++++ .../programs/multi_stark_cuda.rs | 274 + crates/aiur/src/trace_codegen/tests.rs | 550 ++ crates/aiur/src/trace_codegen/tests/blake3.rs | 27 + .../src/trace_codegen/tests/blake3_cuda.rs | 10 + crates/aiur/src/trace_codegen/tests/cuda.rs | 776 ++ .../aiur/src/trace_codegen/tests/generated.rs | 353 + .../src/trace_codegen/tests/generated_cuda.rs | 51 + crates/ixvm-codegen/src/aiur_multi_stark.rs | 512 +- lakefile.lean | 7 + 39 files changed, 40536 insertions(+), 276 deletions(-) create mode 100644 Ix/Aiur/Stages/TraceCodegen.lean create mode 100644 Ix/Aiur/Stages/TraceContract.lean create mode 100644 Ix/Aiur/Stages/TraceCuda.lean create mode 100644 Ix/Aiur/Stages/TracePlan.lean create mode 100644 Ix/Aiur/Stages/TraceReport.lean create mode 100644 Tests/Aiur/TraceCodegen.lean create mode 100644 Tests/Aiur/TraceFixtures.lean create mode 100644 Tests/Aiur/TracePlan.lean create mode 100644 crates/aiur/build.rs create mode 100644 crates/aiur/cuda/generated/blake3.cu create mode 100644 crates/aiur/cuda/generated/fixtures.cu create mode 100644 crates/aiur/cuda/generated/production/ix_aggr.cu create mode 100644 crates/aiur/cuda/generated/production/ixvm.cu create mode 100644 crates/aiur/cuda/generated/production/multi_stark.cu create mode 100644 crates/aiur/cuda/generated/production/trace-manifest.json create mode 100644 crates/aiur/cuda/trace-manifest.json create mode 100644 crates/aiur/src/trace_codegen.rs create mode 100644 crates/aiur/src/trace_codegen/contract.rs create mode 100644 crates/aiur/src/trace_codegen/cuda.rs create mode 100644 crates/aiur/src/trace_codegen/programs/ix_aggr.rs create mode 100644 crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs create mode 100644 crates/aiur/src/trace_codegen/programs/ixvm.rs create mode 100644 crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs create mode 100644 crates/aiur/src/trace_codegen/programs/mod.rs create mode 100644 crates/aiur/src/trace_codegen/programs/multi_stark.rs create mode 100644 crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs create mode 100644 crates/aiur/src/trace_codegen/tests.rs create mode 100644 crates/aiur/src/trace_codegen/tests/blake3.rs create mode 100644 crates/aiur/src/trace_codegen/tests/blake3_cuda.rs create mode 100644 crates/aiur/src/trace_codegen/tests/cuda.rs create mode 100644 crates/aiur/src/trace_codegen/tests/generated.rs create mode 100644 crates/aiur/src/trace_codegen/tests/generated_cuda.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a041d4d3f..d25e20071 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -63,6 +63,7 @@ jobs: # A stale generated trace module is otherwise caught only when the # generated GPU provider registers at proving time. - name: Check generated trace writers, CUDA units and manifest are up to date + if: github.event_name != 'push' run: lake exe ix codegen --trace-bundle --check - name: Check Lean versions match for Ix and compiler bench if: github.event_name != 'push' diff --git a/Ix/Aiur/Codegen/Rust.lean b/Ix/Aiur/Codegen/Rust.lean index ba864d6e4..a10adfe05 100644 --- a/Ix/Aiur/Codegen/Rust.lean +++ b/Ix/Aiur/Codegen/Rust.lean @@ -35,6 +35,7 @@ inductive MatchPat where | litU64 (n : Nat) | wildcard | tuple (elems : Array MatchPat) + | array (elems : Array MatchPat) | constructor (path : Array String) (args : Array MatchPat) deriving Inhabited, BEq @@ -73,6 +74,7 @@ inductive RustExpr where inductive RustStmt where | letStmt (isMut : Bool) (name : String) (ty : Option RustType) (val : RustExpr) | letPattern (pat : MatchPat) (ty : Option RustType) (val : RustExpr) + | assign (target : RustExpr) (val : RustExpr) | exprStmt (e : RustExpr) | returnStmt (e : RustExpr) | ifStmt (cond : RustExpr) (thenStmts : Array RustStmt) @@ -143,6 +145,7 @@ partial def MatchPat.toStr : MatchPat → String | .litU64 n => s!"{n}u64" | .wildcard => "_" | .tuple ps => tupleText (ps.map MatchPat.toStr) + | .array ps => "[" ++ commaSep (ps.map MatchPat.toStr) ++ "]" | .constructor path ps => "::".intercalate path.toList ++ "(" ++ commaSep (ps.map MatchPat.toStr) ++ ")" @@ -167,11 +170,11 @@ partial def RustExpr.toStr : RustExpr → String let callee := match f with | .field .. => "(" ++ f.toStr ++ ")" | _ => f.postfixBase - callee ++ "(" ++ commaSep (xs.map (·.toStr)) ++ ")" + callee ++ "(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" | .methodCall e n xs => e.postfixBase ++ "." ++ n ++ - "(" ++ commaSep (xs.map (·.toStr)) ++ ")" + "(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" | .constGeneric f xs => f.postfixBase ++ "::<" ++ commaSep (xs.map (·.toStr)) ++ ">" - | .index a i => a.postfixBase ++ "[" ++ i.toStr ++ "]" + | .index a i => a.postfixBase ++ "[" ++ i.toStrBare ++ "]" | .field e n => e.postfixBase ++ "." ++ n | .binop op a b => "(" ++ a.toStr ++ " " ++ op.toStr ++ " " ++ b.toStr ++ ")" -- Parenthesize prefix/cast expressions so postfix composition preserves precedence. @@ -182,12 +185,12 @@ partial def RustExpr.toStr : RustExpr → String | .tryExpr e => e.postfixBase ++ "?" | .range a b => (a.map (·.toStr) |>.getD "") ++ ".." ++ (b.map (·.toStr) |>.getD "") - | .macroCall n xs => n ++ "!(" ++ commaSep (xs.map (·.toStr)) ++ ")" - | .arrayLit xs => "[" ++ commaSep (xs.map (·.toStr)) ++ "]" - | .arrayRepeat e n => "[" ++ e.toStr ++ "; " ++ n.toStr ++ "]" - | .tuple xs => tupleText (xs.map (·.toStr)) + | .macroCall n xs => n ++ "!(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" + | .arrayLit xs => "[" ++ commaSep (xs.map (·.toStrBare)) ++ "]" + | .arrayRepeat e n => "[" ++ e.toStrBare ++ "; " ++ n.toStr ++ "]" + | .tuple xs => tupleText (xs.map (·.toStrBare)) | .structLit p fs => "::".intercalate p.toList ++ " { " ++ - commaSep (fs.map fun (n, e) => n ++ ": " ++ e.toStr) ++ " }" + commaSep (fs.map fun (n, e) => n ++ ": " ++ e.toStrBare) ++ " }" | .block b => b.toStr | .unsafeBlock b => "unsafe " ++ b.toStr | .labeledBlock label b => "'" ++ label ++ ": " ++ b.toStr @@ -202,13 +205,24 @@ partial def RustExpr.postfixBase (e : RustExpr) : String := | .closure .. | .ifExpr .. | .matchExpr .. | .range .. => "(" ++ e.toStr ++ ")" | _ => e.toStr +/-- An expression in a position the grammar already delimits (an argument, + an element, an index, an initializer), where its own parentheses would + be redundant and trip the lints. -/ +partial def RustExpr.toStrBare : RustExpr → String + | .binop op a b => a.toStr ++ " " ++ op.toStr ++ " " ++ b.toStr + | .deref e => "*" ++ e.toStr + | .ref e => "&" ++ e.toStr + | .not e => "!" ++ e.toStr + | .cast e t => e.toStr ++ " as " ++ t.toStr + | e => e.toStr + /-- Generated source stays compact: whitespace separates tokens, but nested syntax never expands into additional lines. Each top-level item gets one line. String contents are escaped before rendering, not whitespace-stripped. -/ partial def RustBlock.toStr (b : RustBlock) : String := "{ " ++ stmtsToStr b.stmts ++ (if b.stmts.isEmpty then "" else " ") ++ - (b.tail.map RustExpr.toStr |>.getD "") ++ " }" + (b.tail.map RustExpr.toStrBare |>.getD "") ++ " }" partial def renderMatch (scrut : RustExpr) (arms : Array MatchArm) : String := "match " ++ scrut.toStr ++ " { " ++ @@ -219,11 +233,13 @@ partial def renderMatch (scrut : RustExpr) (arms : Array MatchArm) : String := partial def RustStmt.toStr : RustStmt → String | .letStmt isMut n ty e => "let " ++ (if isMut then "mut " else "") ++ n ++ - (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStr ++ ";" + (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStrBare ++ ";" | .letPattern p ty e => "let " ++ p.toStr ++ - (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStr ++ ";" - | .exprStmt e => e.toStr ++ ";" - | .returnStmt e => "return " ++ e.toStr ++ ";" + (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStrBare ++ ";" + | .assign t e => t.toStr ++ " = " ++ e.toStrBare ++ ";" + | .exprStmt e => e.toStrBare ++ ";" + | .returnStmt (.tuple #[]) => "return;" + | .returnStmt e => "return " ++ e.toStrBare ++ ";" | .ifStmt c t e => "if " ++ c.toStr ++ " " ++ RustBlock.toStr { stmts := t } ++ (e.map (fun ss => " else " ++ RustBlock.toStr { stmts := ss }) |>.getD "") @@ -231,7 +247,7 @@ partial def RustStmt.toStr : RustStmt → String | .block ss => RustBlock.toStr { stmts := ss } | .forStmt p e ss => "for " ++ p.toStr ++ " in " ++ e.toStr ++ " " ++ RustBlock.toStr { stmts := ss } - | .breakWith label e => "break '" ++ label ++ " " ++ e.toStr ++ ";" + | .breakWith label e => "break '" ++ label ++ " " ++ e.toStrBare ++ ";" partial def stmtsToStr (ss : Array RustStmt) : String := " ".intercalate (ss.toList.map RustStmt.toStr) @@ -243,10 +259,12 @@ def RustItem.toStr : RustItem → String let vis := match f.visibility with | .internal => "" | .crate => "pub(crate) " let generics := if f.constParams.isEmpty then "" else "<" ++ commaSep (f.constParams.map fun (n, t) => "const " ++ n ++ ": " ++ t.toStr) ++ ">" + -- A unit return type is left implicit, as the lints prefer. + let returns := if f.returnTy == .tuple #[] then "" else "-> " ++ f.returnTy.toStr ++ " " vis ++ "fn " ++ f.name ++ generics ++ "(" ++ commaSep (f.params.map fun (n, t) => n ++ ": " ++ t.toStr) ++ (if f.params.isEmpty then "" else ",") ++ - ") -> " ++ f.returnTy.toStr ++ " " ++ f.body.toStr ++ "\n" + ") " ++ returns ++ f.body.toStr ++ "\n" end Aiur.Codegen end diff --git a/Ix/Aiur/Stages/TraceCodegen.lean b/Ix/Aiur/Stages/TraceCodegen.lean new file mode 100644 index 000000000..134736651 --- /dev/null +++ b/Ix/Aiur/Stages/TraceCodegen.lean @@ -0,0 +1,391 @@ +module + +public import Ix.Aiur.Stages.Codegen +public import Ix.Aiur.Stages.TracePlan +public import Ix.Aiur.Stages.TraceContract + +public section + +namespace Aiur.TraceCodegen + +open Bytecode TracePlan Codegen + +private inductive Mode where + | row | pack | typed | checked + deriving BEq + +private def setter : SeedWidth → String + | .u8 => "u8" | .u16 => "u16" | .u32 => "u32" | .full => "full" + +private def widthLiteral : SeedWidth → String + | .u8 => "SeedWidth::U8" | .u16 => "SeedWidth::U16" + | .u32 => "SeedWidth::U32" | .full => "SeedWidth::Full" + +private def gOne : RustExpr := .path #["G", "ONE"] +private def gTy : RustType := .named "G" +private def gArray (n : Nat) : RustType := .array gTy (.value n) +private def u64Slice (mutable : Bool) : RustType := .ref mutable (.slice (.named "u64")) +private def unit : RustExpr := .tuple #[] +private def valueExpr (id : ValueId) : RustExpr := .var s!"v_{id}" +/-- A call of a free function or associated function named by its path. -/ +private def call (path : String) (args : Array RustExpr) : RustExpr := + .call (.path (path.splitOn "::").toArray) args +private def method (value : RustExpr) (name : String) (args : Array RustExpr := #[]) : RustExpr := + .methodCall value name args +private def canonical (value : RustExpr) : RustExpr := method value "as_canonical_u64" +private def indexExpr (name : String) (index : Nat) : RustExpr := .index (.var name) (.nat index) +private def declaration (name : String) (value : RustExpr) : RustStmt := .letStmt false name none value +/-- `let [v_a, v_b]: [G; 2] = value;` -/ +private def destructure (ids : Array ValueId) (value : RustExpr) : RustStmt := + .letPattern (.array (ids.map fun id => .binding s!"v_{id}")) (some (gArray ids.size)) value +private def ok : RustStmt := .returnStmt (call "Ok" #[unit]) + +private def Mode.operations (mode : Mode) (plan : FunctionPlan) : Array Nat := + match mode with + | .row => plan.rowOperations + | .pack | .typed => plan.preparationOperations + | .checked => plan.aliasCheckOperations + +private def Mode.values (mode : Mode) (plan : FunctionPlan) : Array ValueId := + match mode with + | .row => plan.rowValues + | .pack | .typed => plan.preparationValues + | .checked => plan.aliasCheckValues + +private def rowWrite (region : String) (index : Nat) (value : RustExpr) : RustStmt := + let base := RustExpr.field (.var "offsets") region + let column := if index == 0 then base else .binop .add base (.nat index) + .assign (.index (.var "row") column) (canonical value) + +private def readExpression (mode : Mode) (op : Operation) (read : ExternalRead) : RustExpr := + let args := op.inputs.map valueExpr + let site := RustExpr.nat op.index + -- `context.::(…)`: the reads that size their result by the + -- operation's output count. + let sized := fun (name : String) (params : Array RustExpr) => + RustExpr.call (.constGeneric (.field (.var "context") name) #[.nat op.outputs.size]) params + let plain := fun (name : String) (params : Array RustExpr) => method (.var "context") name params + .tryExpr <| match read.kind with + | .callResult callee => sized "call" #[site, .nat callee, .ref (.arrayLit args)] + | .returnedCall callee => + if mode == .checked then + sized "check_returned" #[site, .nat callee, .ref (.arrayLit args)] + else sized "returned" #[site] + | .storePointer _ => plain "store" #[site, .ref (.arrayLit args)] + | .loadValues _ => sized "load" #[site, args[0]!] + | .ioInfo => plain "io_info" #[site, args[0]!, .ref (.arrayLit (args.extract 1 args.size))] + | .ioValues _ => sized "io_read" #[site, args[0]!, args[1]!] + | .bigUintResults => plain "big_uint" #[site, args[0]!, args[1]!] + +private def emitOperation (plan : FunctionPlan) (mode : Mode) (op : Operation) : Except String (Array RustStmt) := do + let inputs := op.inputs.map valueExpr + let a := inputs[0]?.getD gZero + let b := inputs[1]?.getD gZero + let unary := fun name => call name #[.ref a] + let binary := fun name => call name #[.ref a, .ref b] + let single := fun value => RustExpr.arrayLit #[value] + let temp := s!"op_{op.index}" + let mut stmts := #[] + let mut auxiliary : Option (Array RustExpr) := none + let expression ← match op.externalRead with + | some read => + if mode == .row then + pure (.arrayLit ((Array.range read.seed.size).map fun i => + call "G::from_u64" #[indexExpr "seed" (read.seed.start + i)])) + else pure (readExpression mode op read) + | none => + match op.opcode with + | .const value => pure (single (gFromU64 value.n)) + | .add .. => pure (single (.binop .add a b)) + | .sub .. => pure (single (.binop .sub a b)) + | .mul .. => pure (single (.binop .mul a b)) + | .eqZero .. => + if op.auxiliaries.size != 0 then + auxiliary := some #[call "g_inverse_value" #[a], valueExpr op.outputs[0]!] + pure (single (gFromBool (method a "is_zero"))) + | .unconstrainedGInverse .. => pure (single (call "g_inverse_value" #[a])) + | .unconstrainedGToBytes .. => + pure (method (method (canonical a) "to_le_bytes") "map" #[.path #["G", "from_u8"]]) + | .u8BitDecomposition .. => + pure (.arrayLit ((Array.range 8).map fun i => + let shifted := if i == 0 then canonical a else .binop .shr (canonical a) (.nat i) + gFromBool (.binop .ne (.binop .bitAnd shifted (.nat 1)) (.nat 0)))) + | .u8ShiftLeft .. => pure (single (unary "Bytes1::shift_left")) + | .u8ShiftRight .. => pure (single (unary "Bytes1::shift_right")) + | .u8Xor .. => pure (single (binary "Bytes2::xor")) + | .u8And .. => pure (single (binary "Bytes2::and")) + | .u8Or .. => pure (single (binary "Bytes2::or")) + | .u8LessThan .. => pure (single (binary "Bytes2::less_than")) + | .u8Add .. | .u8Sub .. | .u8Mul .. | .u8XorSplit4 .. | .u8XorSplit7 .. => + let name := match op.opcode with + | .u8Add .. => "add" | .u8Sub .. => "sub" | .u8Mul .. => "mul" + | .u8XorSplit4 .. => "xor_split4" | _ => "xor_split7" + stmts := stmts.push (declaration temp (binary s!"Bytes2::{name}")) + pure (.arrayLit #[.field (.var temp) "0", .field (.var temp) "1"]) + | .u32LessThan .. => + stmts := stmts.push (declaration temp (call "u32_less_than" #[a, b])) + auxiliary := some ((Array.range 6).map fun i => .index (.field (.var temp) "1") (.nat i)) + pure (single (.field (.var temp) "0")) + | .unconstrainedU32Add .. | .unconstrainedU32Add3 .. => + let words := (Array.range (inputs.size / 4)).map fun i => + call "u32_word" #[.arrayLit (inputs.extract (4*i) (4*i+4))] + pure (call "u32_add" #[.ref (.arrayLit words)]) + | .u32ToField .. => pure (single (call "G::from_u64" #[call "u32_word" #[.arrayLit inputs]])) + | .assertEq .. | .ioSetInfo .. | .ioWrite .. | .debug .. | .u8RangeCheck .. => + pure (.arrayLit #[]) + | .call .. | .load .. | .ioRead .. => + if op.outputs.isEmpty then pure (.arrayLit #[]) + else throw s!"operation {op.index}: missing external read" + | .store .. | .ioGetInfo .. | .unconstrainedBigUintDivMod .. => + throw s!"operation {op.index}: missing external read" + if !op.outputs.isEmpty then + stmts := stmts.push (destructure op.outputs expression) + if mode == .row then + let columns := auxiliary.getD ((op.outputs.extract 0 op.auxiliaries.size).map valueExpr) + unless columns.size == op.auxiliaries.size do + throw s!"operation {op.index}: scalar writer auxiliary count differs from plan" + for i in [:columns.size] do + stmts := stmts.push (rowWrite "auxiliaries" (op.auxiliaries.start + i) columns[i]!) + else if let some read := op.externalRead then + for i in [:op.outputs.size] do + if mode == .typed then + let slot := read.seed.start + i + let width := plan.seedSchema.widths[slot]?.getD .full + let offset := plan.seedSchema.offsets[slot]?.getD (8 * slot) + stmts := stmts.push (.exprStmt (method (.var "seed") (setter width) #[.nat offset, valueExpr op.outputs[i]!])) + else + stmts := stmts.push (.assign (indexExpr "seed" (read.seed.start + i)) (canonical (valueExpr op.outputs[i]!))) + pure stmts + +private structure YieldTarget where + label : String + indices : Array Nat + +mutual + private partial def emitBlock (plan : FunctionPlan) (mode : Mode) (block : BlockPlan) + (target : Option YieldTarget) (depth : Nat) : Except String (Array RustStmt) := do + let mut result := #[] + for index in block.operations do + if (mode.operations plan).contains index then + let some operation := plan.operations[index]? | throw "missing planned operation" + result := result ++ (← emitOperation plan mode operation) + pure (result ++ (← emitControl plan mode block.control target depth)) + + private partial def emitArms (plan : FunctionPlan) (mode : Mode) (discriminant : ValueId) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (inverses : Span) + (target : Option YieldTarget) (depth : Nat) : Except String RustStmt := do + let mut result : Array MatchArm := #[] + for (value, block) in arms do + result := result.push { + pat := .litU64 value.n + body := { stmts := ← emitBlock plan mode block target depth } } + let defaultBody ← match fallback with + | none => pure #[.returnStmt (call "Err" #[call "no_match" #[.nat plan.index, valueExpr discriminant]])] + | some block => do + let mut writes := #[] + if mode == .row then + for ((value, _), i) in arms.zipIdx do + let difference := RustExpr.binop .sub (valueExpr discriminant) (gFromU64 value.n) + writes := writes.push (rowWrite "auxiliaries" (inverses.start + i) (method difference "inverse")) + pure (writes ++ (← emitBlock plan mode block target depth)) + result := result.push { pat := .wildcard, body := { stmts := defaultBody } } + pure (.matchStmt (canonical (valueExpr discriminant)) result) + + private partial def emitControl (plan : FunctionPlan) (mode : Mode) (control : Control) + (target : Option YieldTarget) (depth : Nat) : Except String (Array RustStmt) := do + let selector := fun index => if mode == .row then #[rowWrite "selectors" index gOne] else #[] + match control with + | .returnRow index _ => pure (selector index |>.push ok) + | .yieldRow index ids => + let some target := target | throw "yield has no scalar continuation" + pure (selector index |>.push (.breakWith target.label (.arrayLit (target.indices.map fun i => valueExpr ids[i]!)))) + | .branch discriminant arms fallback inverses _ => + if mode != .row && !(mode.values plan).contains discriminant then return #[ok] + pure #[← emitArms plan mode discriminant arms fallback inverses target depth] + | .continueWith discriminant arms fallback inverses _ merges columns continuation => + if mode != .row && !(mode.values plan).contains discriminant then return #[ok] + let indices := (Array.range merges.size).filter fun i => mode == .row || (mode.values plan).contains merges[i]! + let label := s!"yield_{depth}" + let body ← emitArms plan mode discriminant arms fallback inverses (some ⟨label, indices⟩) (depth + 1) + let merged := indices.map fun i => merges[i]! + let mut result := #[destructure merged (.labeledBlock label { stmts := #[body] })] + if mode == .row then + for i in [:merges.size] do + result := result.push (rowWrite "auxiliaries" (columns.start + i) (valueExpr merges[i]!)) + pure (result ++ (← emitBlock plan mode continuation target depth)) +end + +/-- Every path through a writer ends in `return Ok(())`, a yield or a +`no_match` error. Rust's lints want the function's last statement as a +tail expression, so the final return of the body and of every arm of a +final `match` becomes one. A writer that never fails (no fallible read, no +unmatched discriminant) returns `()` instead, its remaining returns bare. -/ +private partial def tailReturns (fallible : Bool) (stmts : Array RustStmt) : RustBlock := + match stmts.back? with + | some (.returnStmt e) => { stmts := stmts.pop, tail := if fallible then some e else none } + | some (.matchStmt scrutinee arms) => + { stmts := stmts.pop + tail := some (.matchExpr scrutinee (arms.map fun arm => + { arm with body := tailReturns fallible arm.body.stmts })) } + | _ => { stmts } + +mutual + private partial def bareReturns (block : RustBlock) : RustBlock := + { block with stmts := block.stmts.map bareReturn } + private partial def bareReturn : RustStmt → RustStmt + | .returnStmt _ => .returnStmt unit + | .matchStmt scrutinee arms => + .matchStmt scrutinee (arms.map fun arm => { arm with body := bareReturns arm.body }) + | .letPattern pat ty (.labeledBlock label block) => + .letPattern pat ty (.labeledBlock label (bareReturns block)) + | .block stmts => .block (stmts.map bareReturn) + | stmt => stmt +end + +/-- The writer's source and whether it can fail. -/ +private def emitFunction (plan : FunctionPlan) (mode : Mode) : Except String (String × Bool) := do + let mut body := #[] + for i in [:plan.layout.inputSize] do + let value := if mode == .row then call "G::from_u64" #[indexExpr "seed" (1+i)] + else .index (.field (.var "context") "inputs") (.nat i) + body := body.push (declaration s!"v_{i}" value) + body := body ++ (← emitBlock plan mode plan.body none 0) + let rendered := stmtsToStr body + let fallible := rendered.contains '?' || (rendered.splitOn "Err(").length > 1 + let block := tailReturns fallible body + let block := if fallible then block else bareReturns block + let name := if mode == .row then s!"write_{plan.index}" + else s!"pack_{plan.index}" ++ (if mode == .checked then "_checked" else if mode == .typed then "_typed" else "") + let params : Array (String × RustType) := if mode == .row then + #[("seed", u64Slice false), ("offsets", .named "RowOffsets"), ("row", u64Slice true)] + else + #[("context", .ref false (.named "SeedContext<'_>")), + ("seed", if mode == .typed then .ref true (.named "TypedSeed<'_>") else u64Slice true)] + let returnTy : RustType := if fallible then .app "TraceResult" #[.tuple #[]] else .tuple #[] + pure ((RustItem.function { name, params, returnTy, body := block }).toStr, fallible) + +private def vector (xs : Array String) : String := "vec![" ++ ", ".intercalate xs.toList ++ "]" +private def indices (xs : Array Nat) : String := vector (xs.map toString) +private def app (name : String) (args : Array String) : String := name ++ "(" ++ ", ".intercalate args.toList ++ ")" +private def quoted (s : String) : String := (repr s).pretty +private def stringOption (s : Option String) : String := + (s.map fun s => s!"Some({quoted s}.into())").getD "None" + +private def bytecodeOp : Op → String + | .const v => app "Op::Const" #[s!"G::from_u64({v.n})"] + | .add a b => app "Op::Add" #[toString a, toString b] + | .sub a b => app "Op::Sub" #[toString a, toString b] + | .mul a b => app "Op::Mul" #[toString a, toString b] + | .eqZero a => app "Op::EqZero" #[toString a] + | .call f args size unc => app "Op::Call" #[toString f, indices args, toString size, toString unc] + | .store args => app "Op::Store" #[indices args] + | .load size a => app "Op::Load" #[toString size, toString a] + | .assertEq a b msg => app "Op::AssertEq" #[indices a, indices b, stringOption msg] + | .ioGetInfo c key => app "Op::IOGetInfo" #[toString c, indices key] + | .ioSetInfo c key i n => app "Op::IOSetInfo" #[toString c, indices key, toString i, toString n] + | .ioRead c i n => app "Op::IORead" #[toString c, toString i, toString n] + | .ioWrite c args => app "Op::IOWrite" #[toString c, indices args] + | .u8BitDecomposition a => app "Op::U8BitDecomposition" #[toString a] + | .u8ShiftLeft a => app "Op::U8ShiftLeft" #[toString a] + | .u8ShiftRight a => app "Op::U8ShiftRight" #[toString a] + | .u8Xor a b => app "Op::U8Xor" #[toString a, toString b] + | .u8Add a b => app "Op::U8Add" #[toString a, toString b] + | .u8Sub a b => app "Op::U8Sub" #[toString a, toString b] + | .u8Mul a b => app "Op::U8Mul" #[toString a, toString b] + | .u8And a b => app "Op::U8And" #[toString a, toString b] + | .u8Or a b => app "Op::U8Or" #[toString a, toString b] + | .u8LessThan a b => app "Op::U8LessThan" #[toString a, toString b] + | .u32LessThan a b => app "Op::U32LessThan" #[toString a, toString b] + | .u8XorSplit7 a b => app "Op::U8XorSplit7" #[toString a, toString b] + | .u8XorSplit4 a b => app "Op::U8XorSplit4" #[toString a, toString b] + | .debug msg args => app "Op::Debug" #[s!"{quoted msg}.into()", (args.map fun a => s!"Some({indices a})").getD "None"] + | .u8RangeCheck a b => app "Op::U8RangeCheck" #[toString a, toString b] + | .unconstrainedBigUintDivMod a b => app "Op::UnconstrainedBigUintDivMod" #[toString a, toString b] + | .unconstrainedGToBytes a => app "Op::UnconstrainedGToBytes" #[toString a] + | .unconstrainedGInverse a => app "Op::UnconstrainedGInverse" #[toString a] + | .unconstrainedU32Add a b => app "Op::UnconstrainedU32Add" #[indices a, indices b] + | .unconstrainedU32Add3 a b c => app "Op::UnconstrainedU32Add3" #[indices a, indices b, indices c] + | .u32ToField a => app "Op::U32ToField" #[indices a] + +mutual + private partial def bytecodeBlock (block : Bytecode.Block) : String := + "Block { ops: " ++ vector (block.ops.map bytecodeOp) ++ ", ctrl: " ++ bytecodeControl block.ctrl ++ " }" + private partial def bytecodeArms (arms : Array (G × Bytecode.Block)) : String := + "[" ++ ", ".intercalate (arms.toList.map fun (v, b) => + s!"(G::from_u64({v.n}), {bytecodeBlock b})") ++ "].into_iter().collect()" + private partial def bytecodeFallback (block : Option Bytecode.Block) : String := + (block.map fun block => s!"Some(Box::new({bytecodeBlock block}))").getD "None" + private partial def bytecodeControl : Ctrl → String + | .return s xs => app "Ctrl::Return" #[toString s, indices xs] + | .yield s xs => app "Ctrl::Yield" #[toString s, indices xs] + | .match d arms fallback => app "Ctrl::Match" #[toString d, bytecodeArms arms, bytecodeFallback fallback] + | .matchContinue d arms fallback n aux lookup continuation => app "Ctrl::MatchContinue" + #[toString d, bytecodeArms arms, bytecodeFallback fallback, toString n, toString aux, + toString lookup, s!"Box::new({bytecodeBlock continuation})"] +end + +private def layout (l : Bytecode.FunctionLayout) : String := + "FunctionLayout { " ++ s!"input_size: {l.inputSize}, selectors: {l.selectors}, auxiliaries: {l.auxiliaries}, lookups: {l.lookups}" ++ " }" + +private def expected (top : Bytecode.Toplevel) : String := + -- Keep bytecode constructors separate so LLVM does not optimize the entire + -- function library as one allocation-heavy function. + let definitions := top.functions.zipIdx.map fun (f, index) => + s!"#[inline(never)]\nfn expected_function_{index}() -> Function " ++ "{\n" ++ + " Function { body: " ++ bytecodeBlock f.body ++ ", layout: " ++ layout f.layout ++ + s!", entry: {f.entry}, constrained: {f.constrained}" ++ " }\n}\n" + let functions := (Array.range top.functions.size).map fun index => s!"expected_function_{index}()" + let circuits := top.circuits.map fun c => + "Circuit { members: " ++ indices c.members ++ ", layout: " ++ layout c.layout ++ " }" + "\n".intercalate definitions.toList ++ "\nfn expected_program() -> Toplevel {\n Toplevel { functions: " ++ vector functions ++ + ", memory_sizes: " ++ indices top.memorySizes ++ ", circuits: " ++ vector circuits ++ " }\n}\n" + +/-- Scalar and seed writers share the planned SSA values and fixed column spans. +The complete expected bytecode guards runtime binding, including partial coverage. -/ +def emit (top : Bytecode.Toplevel) (cratePath : String := "aiur") + (selected : Option (Array FunIdx) := none) : Except String String := do + let plan ← TracePlan.program top + if let some indices := selected then + for index in indices do + unless (plan.functions[index]?.join).isSome do + throw s!"function {index} is missing or unconstrained" + unless indices.toList.eraseDups.length == indices.size do + throw "duplicate selected function" + let mut source := "// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode.\n" ++ + "#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)]\n" ++ + s!"use {cratePath}::" ++ "{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl},\n" ++ + " execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*};\n" ++ + "use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64};\n\n" + let mut descriptors := #[] + for entry in plan.functions do + match entry with + | none => descriptors := descriptors.push "None" + | some f => + if !(selected.map (·.contains f.index)).getD true then + descriptors := descriptors.push "None" + continue + -- The registry holds fallible writers; an infallible one is wrapped + -- in a closure, which coerces to the function pointer. + let mut entries := #[] + for mode in #[Mode.pack, .typed, .checked, .row] do + let (text, fallible) ← emitFunction f mode + source := source ++ text ++ "\n" + let name := if mode == .row then s!"write_{f.index}" + else s!"pack_{f.index}" ++ (if mode == .checked then "_checked" else if mode == .typed then "_typed" else "") + let args := if mode == .row then "seed, offsets, row" else "context, seed" + entries := entries.push (if fallible then name + else s!"|{args}| " ++ "{ " ++ s!"{name}({args}); Ok(()) " ++ "}") + source := source ++ s!"static SCHEMA_{f.index}: SeedSchema = SeedSchema " ++ "{ widths: &[" ++ + ", ".intercalate (f.seedSchema.widths.toList.map widthLiteral) ++ "], offsets: &[" ++ + ", ".intercalate (f.seedSchema.offsets.toList.map toString) ++ s!"], bytes: {f.seedSchema.bytes} " ++ "};\n\n" + descriptors := descriptors.push ("Some(FunctionWriter { layout: " ++ layout f.layout ++ + s!", output_size: {f.outputSize.getD 0}, seed_words: {f.seedWords}, schema: &SCHEMA_{f.index}, " ++ + s!"pack: {entries[0]!}, pack_typed: {entries[1]!}, " ++ + s!"pack_checked: {entries[2]!}, write: {entries[3]!}" ++ " })") + source := source ++ expected top + pure (source ++ "pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [" ++ TraceContract.fingerprintLiteral top ++ s!"], complete: {selected.isNone}, expected: expected_program, functions: &[\n" ++ + ",\n".intercalate descriptors.toList ++ "\n] };\n") + +end Aiur.TraceCodegen + +end diff --git a/Ix/Aiur/Stages/TraceContract.lean b/Ix/Aiur/Stages/TraceContract.lean new file mode 100644 index 000000000..6aba5f6f9 --- /dev/null +++ b/Ix/Aiur/Stages/TraceContract.lean @@ -0,0 +1,99 @@ +module + +public import Ix.Aiur.Stages.Bytecode +public import Blake3.Rust + +public section + +namespace Aiur.TraceContract +open Bytecode + +/-- The wire format uses explicit variant tags, little-endian u64 lengths and +indices, single-byte flags, and length-prefixed UTF-8 strings. Arm order is +preserved because it determines default-arm inverse columns. -/ +private abbrev Encode := StateM ByteArray +private def byte (n : Nat) : Encode Unit := modify (·.push n.toUInt8) +private def word (n : Nat) : Encode Unit := do + for i in [:8] do byte ((n >>> (8*i)) &&& 255) +private def array (write : α → Encode Unit) (xs : Array α) : Encode Unit := do + word xs.size + for x in xs do write x +private def optional (write : α → Encode Unit) (x : Option α) : Encode Unit := do + match x with + | none => byte 0 + | some x => byte 1; write x +private def text (s : String) : Encode Unit := do + let bytes := s.toUTF8 + word bytes.size + modify (· ++ bytes) +private def indices := array word +private def unary (tag a : Nat) : Encode Unit := byte tag *> word a +private def binary (tag a b : Nat) : Encode Unit := unary tag a *> word b + +private def operation : Op → Encode Unit + | .const x => unary 0 x.n + | .add a b => binary 1 a b + | .sub a b => binary 2 a b + | .mul a b => binary 3 a b + | .eqZero a => unary 4 a + | .call f args n u => do byte 5; word f; indices args; word n; byte (if u then 1 else 0) + | .store xs => byte 6 *> indices xs + | .load n p => binary 7 n p + | .assertEq a b msg => do byte 8; indices a; indices b; optional text msg + | .ioGetInfo c key => do unary 9 c; indices key + | .ioSetInfo c key i n => do unary 10 c; indices key; word i; word n + | .ioRead c i n => do binary 11 c i; word n + | .ioWrite c xs => unary 12 c *> indices xs + | .u8BitDecomposition a => unary 13 a + | .u8ShiftLeft a => unary 14 a + | .u8ShiftRight a => unary 15 a + | .u8Xor a b => binary 16 a b + | .u8Add a b => binary 17 a b + | .u8Mul a b => binary 18 a b + | .u8Sub a b => binary 19 a b + | .u8And a b => binary 20 a b + | .u8Or a b => binary 21 a b + | .u8LessThan a b => binary 22 a b + | .u32LessThan a b => binary 23 a b + | .u8XorSplit7 a b => binary 24 a b + | .u8XorSplit4 a b => binary 25 a b + | .debug msg args => do byte 26; text msg; optional indices args + | .u8RangeCheck a b => binary 27 a b + | .unconstrainedBigUintDivMod a b => binary 28 a b + | .unconstrainedGToBytes a => unary 29 a + | .unconstrainedGInverse a => unary 30 a + | .unconstrainedU32Add a b => do byte 31; indices a; indices b + | .unconstrainedU32Add3 a b c => do byte 32; indices a; indices b; indices c + | .u32ToField a => byte 33 *> indices a + +mutual + private partial def block (b : Block) : Encode Unit := array operation b.ops *> control b.ctrl + private partial def arms (xs : Array (G × Block)) : Encode Unit := + array (fun (value, body) => word value.n *> block body) xs + private partial def control : Ctrl → Encode Unit + | .match d xs fallback => do unary 0 d; arms xs; optional block fallback + | .return s xs => unary 1 s *> indices xs + | .yield s xs => unary 2 s *> indices xs + | .matchContinue d xs fallback n aux lookup continuation => do + unary 3 d; arms xs; optional block fallback + word n; word aux; word lookup; block continuation +end + +private def layout (l : FunctionLayout) : Encode Unit := do + word l.inputSize; word l.selectors; word l.auxiliaries; word l.lookups + +def bytes (top : Toplevel) : ByteArray := Id.run do + let write : Encode Unit := do + array (fun f => do + layout f.layout; byte (if f.entry then 1 else 0); byte (if f.constrained then 1 else 0) + block f.body) top.functions + indices top.memorySizes + return (write.run "aiur-trace-library-v1/seed-v2/writer-v2\x00".toUTF8).2 + +def fingerprint (top : Toplevel) : ByteArray := (Blake3.Rust.hash (bytes top)).val + +def fingerprintLiteral (top : Toplevel) : String := + ", ".intercalate ((fingerprint top).data.toList.map toString) + +end Aiur.TraceContract +end diff --git a/Ix/Aiur/Stages/TraceCuda.lean b/Ix/Aiur/Stages/TraceCuda.lean new file mode 100644 index 000000000..363f05a77 --- /dev/null +++ b/Ix/Aiur/Stages/TraceCuda.lean @@ -0,0 +1,289 @@ +module + +public import Ix.Aiur.Stages.TracePlan +public import Ix.Aiur.Stages.TraceContract + +public section + +namespace Aiur.TraceCuda + +open Bytecode TracePlan + +private def literal (n : Nat) : String := s!"{n}ULL" +private def valueName (id : ValueId) : String := s!"v_{id}" +private def call (name : String) (args : Array String) : String := + name ++ "(" ++ ", ".intercalate args.toList ++ ")" +private def line (depth : Nat) (text : String) : String := + String.ofList (List.replicate (2*depth) ' ') ++ text ++ "\n" +private def column (region : String) (index : Nat) (value : String) : String := + s!"row[layout.{region} + {index}] = {value};" + +private structure Emission where + counter : Nat := 0 + tables : Array String := #[] + +private abbrev EmitM := StateT Emission (Except String) + +private def fresh (stem : String) : EmitM String := do + let n := (← get).counter + modify fun state => { state with counter := n+1 } + pure s!"{stem}_{n}" + +private def emitOperation (operation : Operation) (depth : Nat) : Except String String := do + let args := operation.inputs.map valueName + let a := args[0]?.getD "0ULL" + let b := args[1]?.getD "0ULL" + let temp := s!"op_{operation.index}" + let mut source := "" + let mut auxiliary : Option (Array String) := none + let outputs ← match operation.externalRead with + | some read => pure ((Array.range read.seed.size).map fun i => s!"seed.word({read.seed.start+i})") + | none => + match operation.opcode with + | .const g => pure #[literal g.n] + | .add .. => pure #[call "goldilocks_add" #[a, b]] + | .sub .. => pure #[call "goldilocks_sub" #[a, b]] + | .mul .. => pure #[call "goldilocks_mul" #[a, b]] + | .eqZero .. => + if operation.auxiliaries.size != 0 then + auxiliary := some #[s!"inverse({a})", valueName operation.outputs[0]!] + pure #[s!"uint64_t({a} == 0)"] + | .unconstrainedGInverse .. => pure #[s!"inverse({a})"] + | .unconstrainedGToBytes .. => + pure ((Array.range 8).map fun i => s!"(({a} >> {8*i}) & 255ULL)") + | .u8BitDecomposition .. => + pure ((Array.range 8).map fun i => s!"(({a} >> {i}) & 1ULL)") + | .u8ShiftLeft .. => pure #[s!"(({a} << 1) & 255ULL)"] + | .u8ShiftRight .. => pure #[s!"({a} >> 1)"] + | .u8Xor .. | .u8Add .. | .u8Sub .. | .u8Mul .. | .u8And .. + | .u8Or .. | .u8LessThan .. | .u8XorSplit4 .. | .u8XorSplit7 .. => + source := source ++ line depth s!"if ({a} > 255 || {b} > 255) return 1;" + match operation.opcode with + | .u8Xor .. => pure #[s!"({a} ^ {b})"] + | .u8And .. => pure #[s!"({a} & {b})"] + | .u8Or .. => pure #[s!"({a} | {b})"] + | .u8LessThan .. => pure #[s!"uint64_t({a} < {b})"] + | .u8Add .. => pure #[s!"(({a} + {b}) & 255ULL)", s!"(({a} + {b}) >> 8)"] + | .u8Sub .. => pure #[s!"(({a} - {b}) & 255ULL)", s!"uint64_t({a} < {b})"] + | .u8Mul .. => pure #[s!"(({a} * {b}) & 255ULL)", s!"(({a} * {b}) >> 8)"] + | .u8XorSplit4 .. => pure #[s!"(({a} ^ {b}) >> 4)", s!"((({a} ^ {b}) << 4) & 255ULL)"] + | _ => pure #[s!"(({a} ^ {b}) >> 7)", s!"((({a} ^ {b}) << 1) & 255ULL)"] + | .u32LessThan .. => + source := source ++ line depth s!"if ({a} > 0xffffffffULL || {b} > 0xffffffffULL) return 3;" + source := source ++ line depth s!"const uint32_t {temp} = uint32_t({a}) - uint32_t({b});" + -- Six u16 limbs ordered as a, a - b, b, low limb first: the host + -- witness's scalar range-check queries. + auxiliary := some ((#[a, s!"uint64_t({temp})", b]).flatMap fun word => + #[s!"({word} & 0xffffULL)", s!"(({word} >> 16) & 0xffffULL)"]) + pure #[s!"uint64_t({a} < {b})"] + | .unconstrainedU32Add .. | .unconstrainedU32Add3 .. => + let words := (Array.range (args.size / 4)).map fun i => call "word" (args.extract (4*i) (4*i+4)) + source := source ++ line depth s!"const WordSum {temp} = {call "add_words" words};" + pure (((Array.range 4).map fun i => s!"(({temp}.low >> {8*i}) & 255ULL)").push s!"{temp}.carry") + | .u32ToField .. => pure #[call "canonicalize" #[call "word" args]] + | .assertEq .. | .ioSetInfo .. | .ioWrite .. | .debug .. | .u8RangeCheck .. => pure #[] + | .call .. | .load .. | .ioRead .. => + if operation.outputs.isEmpty then pure #[] else throw "missing CUDA external read" + | .store .. | .ioGetInfo .. | .unconstrainedBigUintDivMod .. => throw "missing CUDA external read" + unless outputs.size == operation.outputs.size do throw "CUDA logical output count differs from plan" + for i in [:outputs.size] do + source := source ++ line depth s!"const uint64_t {valueName operation.outputs[i]!} = {outputs[i]!};" + let columns := auxiliary.getD ((operation.outputs.extract 0 operation.auxiliaries.size).map valueName) + unless columns.size == operation.auxiliaries.size do throw "CUDA auxiliary count differs from plan" + for i in [:columns.size] do + source := source ++ line depth (column "auxiliaries" (operation.auxiliaries.start+i) columns[i]!) + pure source + +private structure YieldTarget where + label : String + merges : Array ValueId + +mutual + private partial def emitBlock (plan : FunctionPlan) (block : BlockPlan) + (target : Option YieldTarget) (depth : Nat) : EmitM String := do + let mut source := "" + for index in block.operations do + if plan.rowOperations.contains index then + let some operation := plan.operations[index]? | throw "missing CUDA operation" + source := source ++ (← emitOperation operation depth) + pure (source ++ (← emitControl plan block.control target depth)) + + private partial def emitArms (plan : FunctionPlan) (discriminant : ValueId) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (inverses : Span) + (target : Option YieldTarget) (depth : Nat) : EmitM String := do + let d := valueName discriminant + let mut source := line depth (s!"switch ({d}) " ++ "{") + for (value, block) in arms do + source := source ++ line (depth+1) (s!"case {literal value.n}: " ++ "{") + source := source ++ (← emitBlock plan block target (depth+2)) + source := source ++ line (depth+1) "}" + source := source ++ line (depth+1) "default: {" + match fallback with + | none => source := source ++ line (depth+2) "return 2;" + | some block => + let maximum := arms.foldl (fun maximum (g, _) => max maximum g.n) 0 + for ((value, _), i) in arms.zipIdx do + let generic := s!"inverse(goldilocks_sub({d}, {literal value.n}))" + let expression ← if maximum < 16 then do + let table ← fresh s!"inverse_{plan.index}" + let items := (Array.range (maximum+1)).map fun n => literal ((G.ofNat n - value).inverse.n) + let declaration := s!"__device__ __constant__ uint64_t {table}[] = " ++ + "{" ++ ", ".intercalate items.toList ++ "};\n" + modify fun state => { state with tables := state.tables.push declaration } + pure s!"({d} <= {literal maximum} ? {table}[{d}] : {generic})" + else pure generic + source := source ++ line (depth+2) (column "auxiliaries" (inverses.start+i) expression) + source := source ++ (← emitBlock plan block target (depth+2)) + pure (source ++ line (depth+1) "}" ++ line depth "}") + + private partial def emitControl (plan : FunctionPlan) (control : Control) + (target : Option YieldTarget) (depth : Nat) : EmitM String := do + match control with + | .returnRow selector _ => + pure (line depth (column "selectors" selector "1") ++ line depth "return 0;") + | .yieldRow selector values => + let some target := target | throw "CUDA yield has no continuation" + let mut source := line depth (column "selectors" selector "1") + for i in [:values.size] do + source := source ++ line depth s!"{valueName target.merges[i]!} = {valueName values[i]!};" + pure (source ++ line depth s!"goto {target.label};") + | .branch discriminant arms fallback inverses _ => + emitArms plan discriminant arms fallback inverses target depth + | .continueWith discriminant arms fallback inverses _ merges columns continuation => + let label ← fresh "continuation" + let mut source := "" + for id in merges do source := source ++ line depth s!"uint64_t {valueName id};" + source := source ++ (← emitArms plan discriminant arms fallback inverses (some ⟨label, merges⟩) depth) + source := source ++ line depth s!"{label}:;" + for i in [:merges.size] do + source := source ++ line depth (column "auxiliaries" (columns.start+i) (valueName merges[i]!)) + pure (source ++ (← emitBlock plan continuation target depth)) +end + +private def loader : SeedWidth → String + | .u8 => "load_u8" | .u16 => "load_u16" | .u32 => "load_u32" | .full => "load_u64" + +private def emitFunction (plan : FunctionPlan) (unit : String) : Except String String := do + let name := s!"{unit}_{plan.index}" + let schema := plan.seedSchema + let (body, state) ← (emitBlock plan plan.body none 1).run {} + let mut source := "".intercalate state.tables.toList + -- Call sites pass literal indices, so the switch folds to one typed load. + source := source ++ s!"template struct Seed_{name} " ++ "{\n const uint8_t* data;\n" ++ + " __device__ __forceinline__ uint64_t word(size_t index) const {\n" ++ + " if constexpr (!Typed) return reinterpret_cast(data)[index];\n" ++ + " switch (index) {\n" + for i in [:schema.widths.size] do + source := source ++ s!" case {i}: return {loader schema.widths[i]!}(data + {schema.offsets[i]!});\n" + source := source ++ " default: return 0;\n }\n }\n};\n" + source := source ++ s!"template __device__ __forceinline__ uint32_t row_{name}(Seed_{name} seed, Layout layout, uint64_t* row) " ++ "{\n" + for i in [:plan.layout.inputSize] do + source := source ++ line 1 s!"const uint64_t v_{i} = seed.word({i+1});" + source := source ++ line 1 s!"row[{i}] = v_{i};" + source := source ++ body ++ "}\n" + source := source ++ s!"template __global__ void kernel_{name}(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) " ++ "{\n" ++ + " const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x;\n" ++ + " if (r >= real) return;\n" ++ + " uint64_t* row = output + r * layout.width;\n" ++ + s!" constexpr size_t stride = Typed ? {plan.typedSeedBytes} : {plan.canonicalSeedBytes};\n" ++ + s!" const Seed_{name} seed" ++ "{seeds + r * stride};\n" ++ + " row[layout.auxiliaries] = seed.word(0);\n" ++ + s!" const uint32_t status = row_{name}(seed, layout, row);\n" ++ + " if (status) atomicCAS(error, 0U, status);\n}\n" + source := source ++ s!"cudaError_t launch_{name}(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) " ++ "{\n" ++ + s!" if (encoding == 1) kernel_{name}<<>>(seeds, real, rows, layout, output, error);\n" ++ + s!" else kernel_{name}<<>>(seeds, real, rows, layout, output, error);\n" ++ + " return cudaGetLastError();\n}\n" + source := source ++ s!"extern \"C\" int aiur_trace_{name}(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) " ++ "{\n" ++ + s!" if (selectors < {plan.layout.inputSize} || auxiliaries < selectors || auxiliaries - selectors < {plan.layout.selectors} || width < auxiliaries || width - auxiliaries < {plan.layout.auxiliaries}) return int(cudaErrorInvalidValue);\n" ++ + s!" const size_t stride = encoding == 1 ? {plan.typedSeedBytes} : encoding == 0 ? {plan.canonicalSeedBytes} : 0;\n" ++ + " return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, " ++ s!"output, launch_{name});\n" ++ "}\n\n" + pure source + +/-- Byte encoding of the selected functions' seed schemas, hashed into the +compiled unit's schema contract. The runtime recomputes it from the Rust +writers' schemas at bind, so a CUDA unit and a seed packer generated from +different compiler revisions cannot agree by total size alone. Little-endian +u64 fields; widths as their byte counts. -/ +private def schemaContract (plan : ProgramPlan) (selected : Option (Array FunIdx)) : ByteArray := Id.run do + let word := fun (bytes : ByteArray) (n : Nat) => Id.run do + let mut bytes := bytes + for i in [:8] do bytes := bytes.push ((n >>> (8*i)) &&& 255).toUInt8 + return bytes + let mut bytes := "aiur-trace-schema-v1\x00".toUTF8 + for entry in plan.functions do + if let some f := entry then + if (selected.map (·.contains f.index)).getD true then + bytes := word bytes f.index + bytes := word bytes f.seedWords + bytes := word bytes f.seedSchema.bytes + for width in f.seedSchema.widths do bytes := bytes.push width.bytes.toUInt8 + for offset in f.seedSchema.offsets do bytes := word bytes offset + return bytes + +private def schemaContractLiteral (plan : ProgramPlan) (selected : Option (Array FunIdx)) : String := + ", ".intercalate ((Blake3.Rust.hash (schemaContract plan selected)).val.data.toList.map toString) + +def validUnit (unit : String) : Bool := + !unit.isEmpty && unit.toList.all (fun c => c.isAlphanum && c.toNat < 128 || c == '_') && + !(unit.toList.head!).isDigit + +def emit (top : Toplevel) (unit : String) (selected : Option (Array FunIdx) := none) : Except String String := do + unless validUnit unit do throw "CUDA unit must be an ASCII identifier" + let plan ← TracePlan.program top + if let some indices := selected then + let mut seen := #[] + for index in indices do + unless (plan.functions[index]?).join.isSome do + throw s!"function {index} has no constrained trace writer" + if seen.contains index then throw s!"duplicate CUDA function {index}" + seen := seen.push index + let mut source := "// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode.\n" ++ + "#include \"trace_primitives.cuh\"\nstatic_assert(aiur_trace::ABI_VERSION == 2, \"trace writer ABI mismatch\");\n" ++ s!"namespace trace_{unit} " ++ "{\nusing namespace aiur_trace;\n\n" + for entry in plan.functions do + if let some function := entry then + if (selected.map (·.contains function.index)).getD true then + source := source ++ (← emitFunction function unit) + pure (source ++ s!"extern \"C\" const uint8_t* aiur_trace_{unit}_contract() " ++ "{\n" ++ + " static const uint8_t hash[32] = {" ++ TraceContract.fingerprintLiteral top ++ "};\n return hash;\n}\n" ++ + s!"extern \"C\" const uint8_t* aiur_trace_{unit}_schema() " ++ "{\n" ++ + " static const uint8_t hash[32] = {" ++ schemaContractLiteral plan selected ++ "};\n return hash;\n}\n}\n") + +/-- Rust registration for the CUDA unit; absent entries remain explicit. -/ +def registry (top : Toplevel) (unit : String) (cratePath : String := "aiur") + (selected : Option (Array FunIdx) := none) : Except String String := do + unless validUnit unit do throw "CUDA unit must be an ASCII identifier" + let plan ← TracePlan.program top + if let some indices := selected then + let mut seen := #[] + for index in indices do + unless (plan.functions[index]?).join.isSome do + throw s!"function {index} has no constrained trace writer" + if seen.contains index then throw s!"duplicate CUDA function {index}" + seen := seen.push index + let mut source := "// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode.\n" ++ + s!"use {cratePath}::trace_codegen::cuda::CudaLibrary;\nunsafe extern \"C\" " ++ "{\n" ++ + s!" fn aiur_trace_{unit}_contract() -> *const u8;\n" ++ + s!" fn aiur_trace_{unit}_schema() -> *const u8;\n" + let mut entries := #[] + let mut words := #[] + let mut typed := #[] + for entry in plan.functions do + words := words.push (toString ((entry.map (·.seedWords)).getD 0)) + typed := typed.push (toString ((entry.map (·.typedSeedBytes)).getD 0)) + match entry with + | some f => + if (selected.map (·.contains f.index)).getD true then + let name := s!"aiur_trace_{unit}_{f.index}" + source := source ++ s!" pub(super) fn {name}(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32;\n" + entries := entries.push s!"Some({name})" + else entries := entries.push "None" + | none => entries := entries.push "None" + pure (source ++ "}\n" ++ + "pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([" ++ TraceContract.fingerprintLiteral top ++ + s!"], aiur_trace_{unit}_contract, aiur_trace_{unit}_schema, &[\n" ++ ",\n".intercalate entries.toList ++ "\n], &[" ++ ", ".intercalate words.toList ++ + "], &[" ++ ", ".intercalate typed.toList ++ "]) };\n") + +end Aiur.TraceCuda + +end diff --git a/Ix/Aiur/Stages/TracePlan.lean b/Ix/Aiur/Stages/TracePlan.lean new file mode 100644 index 000000000..de5783cd5 --- /dev/null +++ b/Ix/Aiur/Stages/TracePlan.lean @@ -0,0 +1,858 @@ +module + +public import Ix.Aiur.Compiler.Layout + +/-! +Main-trace planning over final Aiur bytecode. Column spans are relative to +their input, selector, auxiliary or lookup region, so a function plan can be +instantiated inside a grouped circuit. Value IDs are unique across branches; +bytecode's branch-local indices are resolved while building the plan. +-/ + +public section + +namespace Aiur.TracePlan + +open Bytecode + +abbrev ValueId := Nat + +structure Span where + start : Nat + size : Nat + deriving Inhabited, Repr, BEq + +structure BranchSpace where + auxiliaries : Span + lookups : Span + seeds : Span + deriving Inhabited, Repr + +structure Value where + degree : Nat + producer : Option Nat := none + input : Option Nat := none + rowInputs : Array ValueId := #[] + preparationInputs : Array ValueId := #[] + deriving Inhabited, Repr + +inductive ReadKind where + | callResult (callee : FunIdx) + | returnedCall (callee : FunIdx) + | storePointer (width : Nat) + | loadValues (width : Nat) + | ioInfo + | ioValues (length : Nat) + | bigUintResults + deriving Inhabited, Repr, BEq + +structure ExternalRead where + kind : ReadKind + inputs : Array ValueId + seed : Span + deriving Inhabited, Repr + +structure Operation where + index : Nat + opcode : Op + inputs : Array ValueId + outputs : Array ValueId + outputDegrees : Array Nat + auxiliaries : Span + lookups : Span + externalRead : Option ExternalRead + deriving Repr + +mutual + inductive Control where + | returnRow (selector : SelIdx) (values : Array ValueId) + | yieldRow (selector : SelIdx) (values : Array ValueId) + | branch (discriminant : ValueId) (arms : Array (G × BlockPlan)) + (fallback : Option BlockPlan) (defaultWitnesses : Span) (space : BranchSpace) + | continueWith (discriminant : ValueId) (arms : Array (G × BlockPlan)) + (fallback : Option BlockPlan) (defaultWitnesses : Span) (space : BranchSpace) + (mergeValues : Array ValueId) (mergeColumns : Span) (continuation : BlockPlan) + deriving Inhabited, Repr + + structure BlockPlan where + operations : Array Nat + control : Control + deriving Inhabited, Repr +end + +/-- Storage for one seed word in the typed encoding. The multiplicity word is +always full width: negative field values are ordinary multiplicities. -/ +inductive SeedWidth where + | u8 | u16 | u32 | full + deriving Inhabited, Repr, BEq, DecidableEq + +def SeedWidth.bytes : SeedWidth → Nat + | .u8 => 1 | .u16 => 2 | .u32 => 4 | .full => 8 + +/-- The narrowest width holding every canonical value below `bound`. -/ +def SeedWidth.ofBound (bound : Nat) : SeedWidth := + if bound ≤ 256 then .u8 else if bound ≤ 65536 then .u16 + else if bound ≤ 4294967296 then .u32 else .full + +/-- Byte layout of one typed seed. Words are stored widest first, in index +order within a width, so every word is naturally aligned and the multiplicity +stays at offset zero; the stride is padded to a multiple of eight. -/ +structure SeedSchema where + widths : Array SeedWidth + offsets : Array Nat + bytes : Nat + deriving Inhabited, Repr, BEq + +def SeedSchema.ofWidths (widths : Array SeedWidth) : SeedSchema := Id.run do + let mut offsets := Array.replicate widths.size 0 + let mut cursor := 0 + for width in #[SeedWidth.full, .u32, .u16, .u8] do + for i in [:widths.size] do + if widths[i]! == width then + offsets := offsets.set! i cursor + cursor := cursor + width.bytes + return { widths, offsets, bytes := ((cursor + 7) / 8) * 8 } + +def SeedSchema.canonical (words : Nat) : SeedSchema := + SeedSchema.ofWidths (Array.replicate words .full) + +/-- A schema whose typed and canonical encodings coincide. -/ +def SeedSchema.isCanonical (schema : SeedSchema) : Bool := + schema.widths.all (· == .full) + +structure FunctionPlan where + index : FunIdx + layout : FunctionLayout + outputSize : Option Nat + body : BlockPlan + values : Array Value + operations : Array Operation + /-- Full-width seed words: multiplicity, inputs, then branch-shared reads. -/ + seedWords : Nat + /-- Speculative per-word widths; the packer guards every narrowed word. -/ + seedSchema : SeedSchema + rowOperations : Array Nat + preparationOperations : Array Nat + /-- Preparation dependencies including returned-call alias validation. -/ + aliasCheckOperations : Array Nat + rowValues : Array ValueId + preparationValues : Array ValueId + aliasCheckValues : Array ValueId + deriving Repr + +def FunctionPlan.canonicalSeedBytes (plan : FunctionPlan) : Nat := + 8 * plan.seedWords + +def FunctionPlan.typedSeedBytes (plan : FunctionPlan) : Nat := + plan.seedSchema.bytes + +structure ProgramPlan where + /-- Indexed by function ID; unconstrained functions have no row writer. -/ + functions : Array (Option FunctionPlan) + circuits : Array Circuit + deriving Repr + +/-- The functions of every circuit whose members together pack into at most +half their canonical seeds. A circuit is generated only when every member +is, so the selection is by circuit and the ratio is summed over its members; +it is the static signal that a seed is cheaper to move than the row it +replaces. Row weights, when they exist, should refine this. -/ +def ProgramPlan.compactCircuitFunctions (plan : ProgramPlan) : Array FunIdx := Id.run do + let mut selected := #[] + for circuit in plan.circuits do + let sizes := circuit.members.filterMap fun member => + plan.functions[member]?.join.map fun f => (f.typedSeedBytes, f.canonicalSeedBytes) + let typed := sizes.foldl (fun n (t, _) => n + t) 0 + let canonical := sizes.foldl (fun n (_, c) => n + c) 0 + if sizes.size == circuit.members.size && 2 * typed ≤ canonical then + selected := selected ++ circuit.members + return selected + +private structure Scope where + locals : Array ValueId := #[] + degrees : Array Nat := #[] + auxiliary : Nat := 1 + lookup : Nat := 1 + seed : Nat := 1 + deriving Inhabited + +private def Scope.maxSpace (base other : Scope) : Scope := + { base with + auxiliary := max base.auxiliary other.auxiliary + lookup := max base.lookup other.lookup + seed := max base.seed other.seed } + +private def Scope.spaceTo (start finish : Scope) : BranchSpace := + { auxiliaries := ⟨start.auxiliary, finish.auxiliary - start.auxiliary⟩ + lookups := ⟨start.lookup, finish.lookup - start.lookup⟩ + seeds := ⟨start.seed, finish.seed - start.seed⟩ } + +private structure BuildState where + values : Array Value := #[] + operations : Array Operation := #[] + selectors : Array SelIdx := #[] + outputSize : Option Nat := none + rowRoots : Array ValueId := #[] + rowWrites : Array Nat := #[] + preparationRoots : Array ValueId := #[] + aliasRoots : Array ValueId := #[] + +private abbrev PlanM := StateT BuildState (Except String) + +private structure BlockResult where + plan : BlockPlan + scope : Scope + /-- Yields escaping this block to its enclosing continuation. -/ + yields : Array (Array ValueId) := #[] + deriving Inhabited + +private def resolveLocal (scope : Scope) (index : ValIdx) : PlanM ValueId := + match scope.locals[index]? with + | some value => pure value + | none => throw s!"value {index} is outside the local stack of size {scope.locals.size}" + +private def resolveLocals (scope : Scope) (indices : Array ValIdx) : PlanM (Array ValueId) := + indices.mapM (resolveLocal scope) + +private def newValue (value : Value) : PlanM ValueId := do + let index := (← get).values.size + modify fun state => { state with values := state.values.push value } + pure index + +private def select (layout : FunctionLayout) (selector : SelIdx) : PlanM Unit := do + if selector >= layout.selectors then + throw s!"selector {selector} is outside the declared selector region" + if (← get).selectors.contains selector then + throw s!"selector {selector} is allocated by more than one terminal" + modify fun state => { state with selectors := state.selectors.push selector } + +private partial def returnsHaveSize (block : Bytecode.Block) (size : Nat) : Bool := + match block.ctrl with + | .return _ values => values.size == size + | .yield .. => true + | .match _ arms fallback => + arms.all (fun (_, arm) => returnsHaveSize arm size) && + (fallback.map (fun arm => returnsHaveSize arm size)).getD true + | .matchContinue _ arms fallback _ _ _ continuation => + arms.all (fun (_, arm) => returnsHaveSize arm size) && + (fallback.map (fun arm => returnsHaveSize arm size)).getD true && + returnsHaveSize continuation size + +private def checkWord (values : Array ValIdx) : PlanM Unit := do + unless values.size == 4 do + throw s!"u32 operand has {values.size} bytes instead of 4" + +private def checkMemory (top : Toplevel) (width : Nat) : PlanM Unit := do + unless top.memorySizes.contains width do + throw s!"memory width {width} has no table" + +private def checkOp (top : Toplevel) (op : Op) : PlanM Unit := do + match op with + | .call index inputs outputs unconstrained => + let some callee := top.functions[index]? + | throw s!"call target {index} does not exist" + unless unconstrained || callee.constrained do + throw s!"constrained call targets unconstrained function {index}" + unless inputs.size == callee.layout.inputSize do + throw s!"call {index}: input arity differs from its callee" + unless returnsHaveSize callee.body outputs do + throw s!"call {index}: output arity differs from its callee" + | .store values => checkMemory top values.size + | .load width _ => checkMemory top width + | .assertEq xs ys _ => + unless xs.size == ys.size do + throw "assertion operands have different arities" + | .unconstrainedU32Add xs ys => checkWord xs; checkWord ys + | .unconstrainedU32Add3 xs ys zs => checkWord xs; checkWord ys; checkWord zs + | .u32ToField xs => checkWord xs + | _ => pure () + +private def readKind (op : Op) (returned : Bool) : Option ReadKind := + match op with + | .call callee _ size _ => + if size == 0 then none + else some (if returned then .returnedCall callee else .callResult callee) + | .store values => some (.storePointer values.size) + | .load size _ => if size == 0 then none else some (.loadValues size) + | .ioGetInfo .. => some .ioInfo + | .ioRead _ _ size => if size == 0 then none else some (.ioValues size) + | .unconstrainedBigUintDivMod .. => some .bigUintResults + | _ => none + +private def isReturnedCall (op : Op) (base : Nat) (control : Ctrl) : Bool := + match op, control with + | .call _ _ size _, .return _ values => + size != 0 && values == Array.range' base size + | _, _ => false + +private def planOp (top : Toplevel) (scope : Scope) (op : Op) (control : Ctrl) : + PlanM (Nat × Scope) := do + let index := (← get).operations.size + checkOp top op + let inputs ← resolveLocals scope op.inputs + let initial : Concrete.Bytecode.LayoutMState := + { functionLayout := + { inputSize := 0, selectors := 0, + auxiliaries := scope.auxiliary, lookups := scope.lookup } + memSizes := .empty, degrees := scope.degrees } + let (_, allocated) := (Concrete.Bytecode.opLayout op).run initial + unless allocated.degrees.size == scope.degrees.size + op.outputCount do + throw s!"operation {index}: value count differs from layout degree count" + let auxiliaries : Span := + ⟨scope.auxiliary, allocated.functionLayout.auxiliaries - scope.auxiliary⟩ + let lookups : Span := + ⟨scope.lookup, allocated.functionLayout.lookups - scope.lookup⟩ + let returned := isReturnedCall op scope.locals.size control + let externalRead := (readKind op returned).map fun kind => + { kind, inputs := if returned then #[] else inputs, + seed := ⟨scope.seed, op.outputCount⟩ : ExternalRead } + let rowInputs := if externalRead.isSome then #[] else inputs + let preparationInputs := if returned then #[] else inputs + let outputDegrees := allocated.degrees.extract scope.degrees.size allocated.degrees.size + let outputs ← outputDegrees.mapM fun degree => + newValue { degree, producer := some index, rowInputs, preparationInputs } + let operation : Operation := + { index, opcode := op, inputs, outputs, outputDegrees, + auxiliaries, lookups, externalRead } + modify fun state => { state with operations := state.operations.push operation } + if auxiliaries.size != 0 then + modify fun state => { state with + rowWrites := state.rowWrites.push index + rowRoots := state.rowRoots ++ rowInputs } + if let some read := externalRead then + modify fun state => { state with preparationRoots := state.preparationRoots ++ read.inputs } + if returned then + modify fun state => { state with aliasRoots := state.aliasRoots ++ inputs } + pure (index, { scope with + locals := scope.locals ++ outputs + degrees := allocated.degrees + auxiliary := allocated.functionLayout.auxiliaries + lookup := allocated.functionLayout.lookups + seed := scope.seed + (externalRead.map (·.seed.size)).getD 0 }) + +private def markRowBranch (discriminant : ValueId) : PlanM Unit := + modify fun state => { state with + rowRoots := state.rowRoots.push discriminant } + +mutual + private partial def planBlock (top : Toplevel) (layout : FunctionLayout) + (scope : Scope) (yieldSize : Option Nat) (block : Bytecode.Block) : + PlanM BlockResult := do + let mut scope := scope + let mut operations := #[] + for op in block.ops do + let (index, next) ← planOp top scope op block.ctrl + operations := operations.push index + scope := next + let result ← planControl top layout scope yieldSize block.ctrl + pure { result with plan := { result.plan with operations } } + + private partial def planArms (top : Toplevel) (layout : FunctionLayout) + (scope : Scope) (yieldSize : Option Nat) (arms : Array (G × Bytecode.Block)) + (fallback : Option Bytecode.Block) : + PlanM (Array (G × BlockPlan) × Option BlockPlan × Scope × Array (Array ValueId)) := do + let mut cases : Array G := #[] + let mut plans := #[] + let mut maximum := scope + let mut yields := #[] + for (value, block) in arms do + if cases.contains value then throw s!"duplicate match case {value.n}" + cases := cases.push value + let result ← planBlock top layout scope yieldSize block + plans := plans.push (value, result.plan) + maximum := maximum.maxSpace result.scope + yields := yields ++ result.yields + let mut fallbackPlan := none + if let some block := fallback then + let result ← planBlock top layout + { scope with auxiliary := scope.auxiliary + arms.size } yieldSize block + maximum := maximum.maxSpace result.scope + yields := yields ++ result.yields + fallbackPlan := some result.plan + pure (plans, fallbackPlan, maximum, yields) + + private partial def planControl (top : Toplevel) (layout : FunctionLayout) + (scope : Scope) (yieldSize : Option Nat) (control : Ctrl) : PlanM BlockResult := do + match control with + | .return selector indices => + let values ← resolveLocals scope indices + select layout selector + if let some size := (← get).outputSize then + unless values.size == size do throw "function returns have different arities" + modify fun state => { state with outputSize := some values.size } + pure { plan := ⟨#[], .returnRow selector values⟩, scope } + | .yield selector indices => + let values ← resolveLocals scope indices + unless yieldSize == some values.size do + throw "yield arity differs from its enclosing continuation" + select layout selector + modify fun state => { state with rowRoots := state.rowRoots ++ values } + pure { plan := ⟨#[], .yieldRow selector values⟩, scope, yields := #[values] } + | .match index arms fallback => + let discriminant ← resolveLocal scope index + let defaultWitnesses : Span := + ⟨scope.auxiliary, if fallback.isSome then arms.size else 0⟩ + let (arms, fallback, maximum, yields) ← planArms top layout scope yieldSize arms fallback + markRowBranch discriminant + pure { plan := ⟨#[], .branch discriminant arms fallback defaultWitnesses + (scope.spaceTo maximum)⟩, scope := maximum, yields } + | .matchContinue index arms fallback size sharedAux sharedLookups continuation => + let discriminant ← resolveLocal scope index + let defaultWitnesses : Span := + ⟨scope.auxiliary, if fallback.isSome then arms.size else 0⟩ + let (arms, fallback, maximum, yields) ← planArms top layout scope (some size) arms fallback + let space := scope.spaceTo maximum + unless space.auxiliaries.size == sharedAux && space.lookups.size == sharedLookups do + throw s!"continuation reserves aux/lookups {sharedAux}/{sharedLookups}, \ + but its branches need {space.auxiliaries.size}/{space.lookups.size}" + let mut merges := #[] + for i in [:size] do + let dependencies := yields.foldl (fun deps values => deps.push values[i]!) #[discriminant] + let value ← newValue { + degree := 1, rowInputs := dependencies, preparationInputs := dependencies } + merges := merges.push value + let next : Scope := { maximum with + locals := scope.locals ++ merges + degrees := scope.degrees ++ Array.replicate size 1 + auxiliary := maximum.auxiliary + size } + let result ← planBlock top layout next yieldSize continuation + markRowBranch discriminant + pure { result with plan := ⟨#[], .continueWith discriminant arms fallback + defaultWitnesses space merges ⟨maximum.auxiliary, size⟩ result.plan⟩ } + +end + +mutual + private partial def preparationControls (operations : Array Operation) + (block : BlockPlan) (afterYield : Bool) : Array ValueId × Bool := + let reads := block.operations.any fun index => + (operations[index]?.bind (·.externalRead)).isSome + let (roots, needed) := preparationControl operations block.control afterYield + (roots, reads || needed) + + private partial def preparationControl (operations : Array Operation) + (control : Control) (afterYield : Bool) : Array ValueId × Bool := + match control with + | .returnRow .. => (#[], false) + | .yieldRow .. => (#[], afterYield) + | .branch discriminant arms fallback _ _ => + preparationArms operations discriminant arms fallback afterYield + | .continueWith discriminant arms fallback _ _ _ _ continuation => + let (continuationRoots, continuationNeeded) := + preparationControls operations continuation afterYield + let (branchRoots, branchNeeded) := + preparationArms operations discriminant arms fallback continuationNeeded + (branchRoots ++ continuationRoots, branchNeeded || continuationNeeded) + + private partial def preparationArms (operations : Array Operation) (discriminant : ValueId) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) + (afterYield : Bool) : Array ValueId × Bool := Id.run do + let mut roots := #[] + -- Nested returns can bypass a read in an enclosing continuation. + -- Propagate that continuation demand through every intervening branch. + let mut needed := afterYield + for (_, block) in arms do + let (branchRoots, branchNeeded) := preparationControls operations block afterYield + roots := roots ++ branchRoots + needed := needed || branchNeeded + if let some block := fallback then + let (branchRoots, branchNeeded) := preparationControls operations block afterYield + roots := roots ++ branchRoots + needed := needed || branchNeeded + return (if needed then roots.push discriminant else roots, needed) +end + +private def dependencies (values : Array Value) (operationCount : Nat) + (roots : Array ValueId) (writes : Array Nat) (preparation : Bool) : + Array Nat × Array ValueId := Id.run do + let mut needed := Array.replicate values.size false + let mut operations := Array.replicate operationCount false + for root in roots do needed := needed.set! root true + for write in writes do operations := operations.set! write true + -- Dependencies precede their value, including continuation merges, whose + -- alternatives have already been assigned distinct IDs. + for offset in [:values.size] do + let index := values.size - 1 - offset + if needed[index]! then + let value := values[index]! + if let some producer := value.producer then + operations := operations.set! producer true + let inputs := if preparation then value.preparationInputs else value.rowInputs + for input in inputs do needed := needed.set! input true + return ((Array.range operationCount).filter fun index => operations[index]!, + (Array.range values.size).filter fun index => needed[index]!) + +/-! ## Seed value bounds + +Exclusive upper bounds on canonical values, `gSize` when unknown. A word is +narrowed when any use anywhere in the function constrains it: byte-table +operations, u32 comparisons, equality assertions, exhaustive matches, +arguments passed to constrained callees whose own inputs are narrow, and +pointer positions. Values produced by byte operations, constants, bounded +arithmetic, calls and memory loads carry their bounds forward, through +continuation merges, function outputs and memory tables. + +The union over paths is speculative on purpose: a value used as a byte on one +path is a byte on every path in the typed source language, and the packer +guards each narrowed word, so a wrong speculation costs a full-width span, +never a wrong row. Pointers are the other speculation: a memory pointer is +its record's base plus a table index and an I/O index counts buffer entries, +so both are taken to fit 32 bits. -/ + +private def unbounded : Nat := gSize.toNat + +/-- Memory pointers and I/O indices. -/ +private def pointerBound : Nat := 4294967296 + +/-- Bounds visible across the library: a function's inputs from their uses +inside it, its outputs from their producers at every return. -/ +structure FunctionBounds where + inputs : Array Nat + outputs : Array Nat + deriving Inhabited, Repr, BEq + +/-- What one function's analysis may assume about the rest of the library: +callee bounds, and per memory width the bound of each stored value over +every store site. A table with no store site is unknown. -/ +structure Library where + callee : FunIdx → Option FunctionBounds + memory : Nat → Option (Array Nat) + +def Library.empty : Library := { callee := fun _ => none, memory := fun _ => none } + +private def saturate (n : Nat) : Nat := min n unbounded + +private def producedBounds (lib : Library) (op : Operation) (bound : ValueId → Nat) : Array Nat := + let a := (op.inputs[0]?.map bound).getD unbounded + let b := (op.inputs[1]?.map bound).getD unbounded + let unknown := Array.replicate op.outputs.size unbounded + let bounds := match op.opcode with + | .const g => #[g.n + 1] + | .add .. => #[saturate (a + b - 1)] + | .mul .. => #[saturate ((a - 1) * (b - 1) + 1)] + | .eqZero .. | .u8LessThan .. | .u32LessThan .. => #[2] + | .u8BitDecomposition .. => Array.replicate 8 2 + | .unconstrainedGToBytes .. => Array.replicate 8 256 + | .u8ShiftLeft .. | .u8ShiftRight .. | .u8Xor .. | .u8And .. | .u8Or .. => #[256] + | .u8Add .. | .u8Sub .. => #[256, 2] + | .u8Mul .. => #[256, 256] + | .u8XorSplit4 .. => #[16, 256] + | .u8XorSplit7 .. => #[2, 256] + | .unconstrainedU32Add .. => #[256, 256, 256, 256, 2] + | .unconstrainedU32Add3 .. => #[256, 256, 256, 256, 3] + | .u32ToField .. => #[pointerBound] + | .call index _ _ false => ((lib.callee index).map (·.outputs)).getD unknown + | .store .. => #[pointerBound] + | .load width _ => (lib.memory width).getD unknown + | .ioGetInfo .. | .unconstrainedBigUintDivMod .. => #[pointerBound, pointerBound] + | _ => unknown + if bounds.size == op.outputs.size then bounds else unknown + +private def requiredBounds (lib : Library) (op : Operation) (bound : ValueId → Nat) : + Array (ValueId × Nat) := + match op.opcode with + | .u8BitDecomposition .. | .u8ShiftLeft .. | .u8ShiftRight .. | .u8Xor .. | .u8Add .. + | .u8Mul .. | .u8Sub .. | .u8And .. | .u8Or .. | .u8LessThan .. | .u8XorSplit7 .. + | .u8XorSplit4 .. | .u8RangeCheck .. | .unconstrainedU32Add .. | .unconstrainedU32Add3 .. + | .u32ToField .. => op.inputs.map (·, 256) + | .u32LessThan .. => op.inputs.map (·, pointerBound) + -- Operands are resolved value ids in `Op.inputs` order: the load pointer is + -- the only operand, the I/O index follows the channel, and `ioSetInfo` + -- ends with its index and length. + | .load .. => (op.inputs[0]?.map (·, pointerBound)).toArray + | .ioRead .. => (op.inputs[1]?.map (·, pointerBound)).toArray + | .ioSetInfo .. => + (op.inputs.extract (op.inputs.size - 2) op.inputs.size).map (·, pointerBound) + | .assertEq xs _ _ => + (Array.range xs.size).flatMap fun i => + match op.inputs[i]?, op.inputs[i + xs.size]? with + | some x, some y => #[(x, bound y), (y, bound x)] + | _, _ => #[] + | .call index _ _ false => + match lib.callee index with + | some bounds => op.inputs.zip bounds.inputs + | none => #[] + | _ => #[] + +private structure Analysis where + produced : Array Nat + required : Array Nat + /-- Pointwise maximum over returns; empty until the first return. -/ + outputs : Array Nat + /-- Every store site: the memory width and its operands' bounds. -/ + stores : Array (Nat × Array Nat) + +private def Analysis.bound (a : Analysis) (value : ValueId) : Nat := + min (a.produced[value]?.getD unbounded) (a.required[value]?.getD unbounded) + +private def constrain (required : Array Nat) (value : ValueId) (bound : Nat) : Array Nat := + required.modify value (min · bound) + +/-- Without a fallback arm, the discriminant is one of the case values. -/ +private def guardDiscriminant (discriminant : ValueId) (arms : Array (G × BlockPlan)) + (fallback : Option BlockPlan) (required : Array Nat) : Array Nat := + if fallback.isSome then required + else constrain required discriminant (arms.foldl (fun m (g, _) => max m g.n) 0 + 1) + +mutual + /-- Yields escaping a block to its enclosing continuation, in plan order. -/ + private partial def blockYields (block : BlockPlan) : Array (Array ValueId) := + match block.control with + | .returnRow .. => #[] + | .yieldRow _ values => #[values] + | .branch _ arms fallback _ _ => armYields arms fallback + | .continueWith _ _ _ _ _ _ _ continuation => blockYields continuation + + private partial def armYields (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) : + Array (Array ValueId) := + arms.foldl (fun yields (_, block) => yields ++ blockYields block) #[] ++ + (fallback.map blockYields).getD #[] +end + +mutual + private partial def produceBlock (plan : FunctionPlan) (lib : Library) + (block : BlockPlan) (a : Analysis) : Analysis := + let a := block.operations.foldl (init := a) fun a index => + match plan.operations[index]? with + | some op => + let bound := fun v => a.produced[v]?.getD unbounded + let bounds := producedBounds lib op bound + let stores := match op.opcode with + | .store .. => a.stores.push (op.inputs.size, op.inputs.map bound) + | _ => a.stores + let produced := (op.outputs.zip bounds).foldl (fun p (v, b) => p.set! v b) a.produced + { a with stores := stores, produced := produced } + | none => a + produceControl plan lib block.control a + + private partial def produceArms (plan : FunctionPlan) (lib : Library) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (a : Analysis) : Analysis := + let a := arms.foldl (fun a (_, block) => produceBlock plan lib block a) a + match fallback with + | some block => produceBlock plan lib block a + | none => a + + private partial def produceControl (plan : FunctionPlan) (lib : Library) + (control : Control) (a : Analysis) : Analysis := + match control with + | .returnRow _ values => + let bounds := values.map fun v => a.produced[v]?.getD unbounded + { a with outputs := if a.outputs.isEmpty then bounds + else (a.outputs.zip bounds).map fun (x, y) => max x y } + | .yieldRow .. => a + | .branch _ arms fallback _ _ => produceArms plan lib arms fallback a + | .continueWith _ arms fallback _ _ merges _ continuation => + let a := produceArms plan lib arms fallback a + let yields := armYields arms fallback + let produced := merges.zipIdx.foldl (init := a.produced) fun p (merge, i) => + p.set! merge (yields.foldl (init := 1) fun b values => + max b ((values[i]?.map fun v => a.produced[v]?.getD unbounded).getD unbounded)) + produceBlock plan lib continuation { a with produced } +end + +mutual + private partial def requireBlock (plan : FunctionPlan) (lib : Library) + (block : BlockPlan) (produced : Array Nat) (required : Array Nat) : Array Nat := + let required := block.operations.foldl (init := required) fun r index => + match plan.operations[index]? with + | some op => + (requiredBounds lib op fun v => produced[v]?.getD unbounded).foldl + (fun r (v, b) => constrain r v b) r + | none => r + requireControl plan lib block.control produced required + + private partial def requireArms (plan : FunctionPlan) (lib : Library) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (produced : Array Nat) + (required : Array Nat) : Array Nat := + let required := arms.foldl (fun r (_, block) => requireBlock plan lib block produced r) required + match fallback with + | some block => requireBlock plan lib block produced required + | none => required + + private partial def requireControl (plan : FunctionPlan) (lib : Library) + (control : Control) (produced : Array Nat) (required : Array Nat) : Array Nat := + match control with + | .returnRow .. | .yieldRow .. => required + | .branch discriminant arms fallback _ _ => + requireArms plan lib arms fallback produced + (guardDiscriminant discriminant arms fallback required) + | .continueWith discriminant arms fallback _ _ merges _ continuation => + -- The continuation's uses of a merge bound every yield feeding it, so + -- the continuation is analyzed before the arms that yield into it. + let required := requireBlock plan lib continuation produced + (guardDiscriminant discriminant arms fallback required) + let required := (armYields arms fallback).foldl (init := required) fun r values => + (merges.zip values).foldl (fun r (merge, v) => constrain r v (r[merge]?.getD unbounded)) r + requireArms plan lib arms fallback produced required +end + +private def produce (plan : FunctionPlan) (lib : Library) : Analysis := + let unknown := Array.replicate plan.values.size unbounded + let a := produceBlock plan lib plan.body + { produced := unknown, required := unknown, outputs := #[], stores := #[] } + if a.outputs.isEmpty then { a with outputs := Array.replicate (plan.outputSize.getD 0) unbounded } else a + +private def analyze (plan : FunctionPlan) (lib : Library) : Analysis × FunctionBounds := + let a := produce plan lib + let a := { a with required := requireBlock plan lib plan.body a.produced a.required } + -- Input values are allocated first, so input `i` is value `i`. + (a, { inputs := (Array.range plan.layout.inputSize).map a.bound, outputs := a.outputs }) + +/-- Bounds shared across functions are rounded to width classes so that both +library fixpoints range over a finite lattice. -/ +private def roundBound (bound : Nat) : Nat := + if bound ≤ 256 then 256 else if bound ≤ 65536 then 65536 + else if bound ≤ 4294967296 then 4294967296 else unbounded + +/-- One width per seed word: the multiplicity stays full, inputs and read +results take their value bounds, and a slot shared by mutually exclusive +reads takes the widest. Unused slots are always zero and pack as one byte. -/ +private def seedSchema (plan : FunctionPlan) (a : Analysis) : SeedSchema := Id.run do + let mut bounds := Array.replicate plan.seedWords 1 + bounds := bounds.set! 0 unbounded + for i in [:plan.layout.inputSize] do + bounds := bounds.modify (1 + i) (max · (a.bound i)) + for op in plan.operations do + if let some read := op.externalRead then + for j in [:op.outputs.size] do + bounds := bounds.modify (read.seed.start + j) (max · (a.bound op.outputs[j]!)) + return SeedSchema.ofWidths (bounds.map SeedWidth.ofBound) + +/-- Joins every store site's operand bounds per memory width, rounded. -/ +private def memoryBounds (stores : Array (Nat × Array Nat)) : Array (Nat × Array Nat) := + stores.foldl (init := #[]) fun table (width, bounds) => + let bounds := bounds.map roundBound + match table.findIdx? (·.1 == width) with + | some i => table.modify i fun (width, joined) => + (width, (joined.zip bounds).map fun (x, y) => max x y) + | none => table.push (width, bounds) + +/-- Recomputes every schema with bounds shared across the library. + +Output and memory bounds are the least fixpoint, iterated upward from the +smallest class: a recursive function whose returns are its own call results +or byte results then narrows to bytes, and a table only ever stored with +bytes loads bytes, which a downward iteration from unknown never would. +Every finite execution is covered by induction on its call depth, so the +limit is a valid bound; a phase that does not settle falls back to unknown. +Input bounds are then iterated downward from unknown, where every iterate is +already valid and stopping early is safe. -/ +def resolveSchemas (functions : Array (Option FunctionPlan)) : Array (Option FunctionPlan) := Id.run do + let plans := functions.filterMap id + let mut outputs : Array (Option (Array Nat)) := functions.map fun plan => plan.map fun plan => + Array.replicate (plan.outputSize.getD 0) 256 + -- Only tables with a store site have bounds; the rest stay unknown. + let mut memory : Array (Nat × Array Nat) := memoryBounds <| + (plans.foldl (fun stores plan => stores ++ (produce plan Library.empty).stores) #[]).map + fun (width, bounds) => (width, bounds.map fun _ => 256) + let mut settled := false + for _ in [:64] do + let lib : Library := { + callee := fun index => (outputs[index]?.join).map fun outputs => { inputs := #[], outputs } + memory := fun width => (memory.find? (·.1 == width)).map (·.2) } + let analyses := functions.map fun plan => plan.map fun plan => produce plan lib + let nextOutputs := analyses.map fun a => a.map fun a => a.outputs.map roundBound + let nextMemory := memoryBounds <| + analyses.foldl (fun stores a => stores ++ (a.map (·.stores)).getD #[]) #[] + if nextOutputs == outputs && nextMemory == memory then + settled := true + break + outputs := nextOutputs + memory := nextMemory + unless settled do + outputs := functions.map fun plan => plan.map fun plan => + Array.replicate (plan.outputSize.getD 0) unbounded + memory := #[] + let mut inputs : Array (Option (Array Nat)) := functions.map fun plan => plan.map fun plan => + Array.replicate plan.layout.inputSize unbounded + let lib := fun (inputs : Array (Option (Array Nat))) => ({ + callee := fun index => + match inputs[index]?.join, outputs[index]?.join with + | some inputs, some outputs => some { inputs, outputs } + | _, _ => none + memory := fun width => (memory.find? (·.1 == width)).map (·.2) } : Library) + for _ in [:64] do + let next := functions.map fun plan => plan.map fun plan => + (analyze plan (lib inputs)).2.inputs.map roundBound + if next == inputs then break + inputs := next + return functions.map fun plan => plan.map fun plan => + { plan with seedSchema := seedSchema plan (analyze plan (lib inputs)).1 } + +def function (top : Toplevel) (index : FunIdx) : Except String FunctionPlan := do + let some definition := top.functions[index]? | throw s!"function {index} does not exist" + unless definition.constrained do throw s!"function {index} has no constrained trace" + let build : PlanM BlockResult := do + let mut inputs := #[] + for i in [:definition.layout.inputSize] do + let value ← newValue { degree := 1, input := some i } + inputs := inputs.push value + let scope : Scope := { + locals := inputs, degrees := Array.replicate inputs.size 1, seed := 1 + inputs.size } + planBlock top definition.layout scope none definition.body + let (result, state) ← (build.run {}).mapError fun error => s!"function {index}: {error}" + let computed : FunctionLayout := + { inputSize := definition.layout.inputSize, selectors := state.selectors.size, + auxiliaries := result.scope.auxiliary, lookups := result.scope.lookup } + unless computed == definition.layout do + throw s!"function {index}: planned layout {repr computed} differs from {repr definition.layout}" + let (_, oracle) := (Concrete.Bytecode.blockLayout definition.body).run + (Concrete.Bytecode.LayoutMState.new definition.layout.inputSize) + let oracleLayout := { oracle.functionLayout with lookups := oracle.functionLayout.lookups + 1 } + unless computed == oracleLayout do + throw s!"function {index}: trace plan differs from the layout allocator" + let reads := state.operations.filterMap fun op => op.externalRead.map fun _ => op.index + let (controlRoots, _) := preparationControls state.operations result.plan false + let preparationRoots := state.preparationRoots ++ controlRoots + let (rowOperations, rowValues) := dependencies state.values state.operations.size + state.rowRoots state.rowWrites false + let (preparationOperations, preparationValues) := dependencies state.values state.operations.size + preparationRoots reads true + let (aliasCheckOperations, aliasCheckValues) := dependencies state.values state.operations.size + (preparationRoots ++ state.aliasRoots) reads true + let plan : FunctionPlan := { + index, layout := computed, outputSize := state.outputSize, body := result.plan, + values := state.values, operations := state.operations, seedWords := result.scope.seed + seedSchema := SeedSchema.canonical result.scope.seed + rowOperations, preparationOperations, aliasCheckOperations + rowValues, preparationValues, aliasCheckValues } + -- Without the library, callees and memory contribute no bounds; `program` + -- refines this. + pure { plan with seedSchema := seedSchema plan (analyze plan Library.empty).1 } + +private def validateCircuits (top : Toplevel) : Except String Unit := do + let mut seen := Array.replicate top.functions.size false + for circuit in top.circuits do + if circuit.members.isEmpty then throw s!"circuit {circuit.name} has no members" + let mut merged : FunctionLayout := + { inputSize := 0, selectors := 0, auxiliaries := 0, lookups := 0 } + for member in circuit.members do + let some definition := top.functions[member]? + | throw s!"circuit {circuit.name}: missing member {member}" + unless definition.constrained do + throw s!"circuit {circuit.name}: member {member} is unconstrained" + if seen[member]! then throw s!"function {member} occurs in more than one circuit" + seen := seen.set! member true + merged := merged.merge definition.layout + unless merged == circuit.layout do + throw s!"circuit {circuit.name}: merged member layout differs from its declared layout" + for i in [:top.functions.size] do + unless seen[i]! == top.functions[i]!.constrained do + throw s!"constrained function {i} has no circuit" + +def program (top : Toplevel) : Except String ProgramPlan := do + if top.functions.size >= gSize.toNat then throw "function count exceeds the field characteristic" + for size in top.memorySizes do + if size >= gSize.toNat then throw "memory width exceeds the field characteristic" + validateCircuits top + let mut functions := #[] + for i in [:top.functions.size] do + if top.functions[i]!.constrained then + functions := functions.push (some (← function top i)) + else + functions := functions.push none + pure { functions := resolveSchemas functions, circuits := top.circuits } + +end Aiur.TracePlan + +end diff --git a/Ix/Aiur/Stages/TraceReport.lean b/Ix/Aiur/Stages/TraceReport.lean new file mode 100644 index 000000000..243a83ed4 --- /dev/null +++ b/Ix/Aiur/Stages/TraceReport.lean @@ -0,0 +1,181 @@ +module + +public import Lean.Data.Json +public import Ix.Aiur.Compiler +public import Ix.Aiur.Stages.TracePlan + +public section + +namespace Aiur.TraceReport + +open Lean Bytecode TracePlan + +private def spanJson (span : Span) : Json := + Json.mkObj [("start", toJson span.start), ("size", toJson span.size)] + +private def layoutJson (layout : Bytecode.FunctionLayout) : Json := + Json.mkObj [ + ("inputs", toJson layout.inputSize), + ("selectors", toJson layout.selectors), + ("auxiliaries", toJson layout.auxiliaries), + ("lookups", toJson layout.lookups), + ("main_width", toJson layout.width)] + +private def spaceJson (space : BranchSpace) : Json := + Json.mkObj [ + ("auxiliaries", spanJson space.auxiliaries), + ("lookups", spanJson space.lookups), + ("seeds", spanJson space.seeds)] + +private def readJson (read : ExternalRead) : Json := + let (kind, metadata) : String × List (String × Json) := match read.kind with + | .callResult callee => ("call_result", [("callee", toJson callee)]) + | .returnedCall callee => ("returned_call", [("callee", toJson callee)]) + | .storePointer width => ("store_pointer", [("memory_width", toJson width)]) + | .loadValues width => ("load_values", [("memory_width", toJson width)]) + | .ioInfo => ("io_info", []) + | .ioValues length => ("io_values", [("length", toJson length)]) + | .bigUintResults => ("big_uint_results", []) + Json.mkObj ([("kind", toJson kind), ("inputs", toJson read.inputs), + ("seed", spanJson read.seed)] ++ metadata) + +mutual + private partial def blockJson (block : BlockPlan) : Json := + Json.mkObj [ + ("operations", toJson block.operations), + ("control", controlJson block.control)] + + private partial def controlJson (control : Control) : Json := + match control with + | .returnRow selector values => Json.mkObj [ + ("kind", toJson "return"), ("selector", toJson selector), ("values", toJson values)] + | .yieldRow selector values => Json.mkObj [ + ("kind", toJson "yield"), ("selector", toJson selector), ("values", toJson values)] + | .branch discriminant arms fallback witnesses space => + Json.mkObj ([("kind", toJson "match")] ++ + branchJson discriminant arms fallback witnesses space) + | .continueWith discriminant arms fallback witnesses space merges columns continuation => + Json.mkObj ([("kind", toJson "match_continue"), + ("merge_values", toJson merges), ("merge_columns", spanJson columns), + ("continuation", blockJson continuation)] ++ + branchJson discriminant arms fallback witnesses space) + + private partial def branchJson (discriminant : ValueId) (arms : Array (G × BlockPlan)) + (fallback : Option BlockPlan) (witnesses : Span) (space : BranchSpace) : List (String × Json) := + [("discriminant", toJson discriminant), + ("arms", Json.arr <| arms.map fun (value, block) => + Json.mkObj [("value", toJson (toString value.n)), ("block", blockJson block)]), + ("fallback", (fallback.map blockJson).getD Json.null), + ("default_witnesses", spanJson witnesses), + ("shared", spaceJson space)] +end + +private def operationJson (plan : FunctionPlan) (op : Operation) : Json := + Json.mkObj [ + ("index", toJson op.index), + ("bytecode", toJson (reprStr op.opcode)), + ("inputs", toJson op.inputs), + ("outputs", toJson op.outputs), + ("output_degrees", toJson op.outputDegrees), + ("auxiliaries", spanJson op.auxiliaries), + ("lookups", spanJson op.lookups), + ("external_read", (op.externalRead.map readJson).getD Json.null), + ("row_needed", toJson (plan.rowOperations.contains op.index)), + ("preparation_needed", toJson (plan.preparationOperations.contains op.index)), + ("alias_check_needed", toJson (plan.aliasCheckOperations.contains op.index))] + +private def functionJson (aliases : Array String) (plan : FunctionPlan) : Json := + let reads := plan.operations.filter (·.externalRead.isSome) + let preparationArithmetic := plan.operations.filter fun op => + plan.preparationOperations.contains op.index && op.externalRead.isNone + Json.mkObj [ + ("index", toJson plan.index), + ("names", toJson aliases), + ("layout", layoutJson plan.layout), + ("output_size", toJson plan.outputSize), + ("real_rows", Json.null), + ("static_operation_sites", toJson plan.operations.size), + ("static_external_read_sites", toJson reads.size), + ("preparation_arithmetic_sites", toJson (preparationArithmetic.map (·.index))), + ("row_operation_sites", toJson plan.rowOperations), + ("preparation_operation_sites", toJson plan.preparationOperations), + ("alias_check_operation_sites", toJson plan.aliasCheckOperations), + ("singleton_main_bytes_per_real_row", toJson (8 * plan.layout.width)), + ("canonical_seed_words", toJson plan.seedWords), + ("canonical_seed_bytes", toJson plan.canonicalSeedBytes), + ("typed_seed_bytes", toJson plan.typedSeedBytes), + ("typed_seed_word_bits", toJson (plan.seedSchema.widths.map fun width => 8 * width.bytes)), + ("values", Json.arr <| plan.values.map fun value => Json.mkObj [ + ("degree", toJson value.degree), ("producer", toJson value.producer), + ("input", toJson value.input), ("row_inputs", toJson value.rowInputs), + ("preparation_inputs", toJson value.preparationInputs)]), + ("operations", Json.arr (plan.operations.map (operationJson plan))), + ("body", blockJson plan.body)] + +private def aliases (compiled : CompiledToplevel) : Array (Array String) := + let names := compiled.nameMap.fold + (init := Array.replicate compiled.bytecode.functions.size (#[] : Array String)) + fun names name index => names.set! index (names[index]!.push (toString name)) + names.map fun names => names.qsort (· < ·) + +private def circuitJson (top : Toplevel) (names : Array (Array String)) + (index : Nat) (circuit : Circuit) : Json := Id.run do + let mut selectorBase := circuit.layout.inputSize + let mut members := #[] + for member in circuit.members do + members := members.push <| Json.mkObj [ + ("function", toJson member), ("names", toJson names[member]!), + ("selector_base", toJson selectorBase), + ("auxiliary_base", toJson (circuit.layout.inputSize + circuit.layout.selectors)), + ("real_rows", Json.null)] + selectorBase := selectorBase + top.functions[member]!.layout.selectors + let name := if circuit.members.size == 1 then + (names[circuit.members[0]!]![0]?).getD s!"function_{circuit.members[0]!}" + else circuit.name + let branchless := if circuit.members.size == 1 && circuit.layout.selectors == 1 then + match top.functions[circuit.members[0]!]!.body.ctrl with + | .return .. | .yield .. => true + | _ => false + else false + return Json.mkObj [ + ("index", toJson index), ("name", toJson name), + ("layout", layoutJson circuit.layout), ("branchless", toJson branchless), + ("members", Json.arr members), ("real_rows", Json.null), ("padded_height", Json.null)] + +/-- A deterministic static inventory. Dynamic row weights and timings are +absent explicitly; the report is not a compatibility digest or a benchmark. -/ +def program (label : String) (compiled : CompiledToplevel) : Except String Json := do + let top := compiled.bytecode + let plan ← TracePlan.program top + let names := aliases compiled + let functions := plan.functions.filterMap fun plan => plan.map fun plan => + functionJson names[plan.index]! plan + let memories := top.memorySizes.mapIdx fun index width => Json.mkObj [ + ("index", toJson (top.circuits.size + index)), ("kind", toJson "memory"), + ("value_width", toJson width), ("main_width", toJson (width + 3)), + ("canonical_seed_bytes_per_real_row", toJson (8 * (width + 1))), + ("preserve_zero_multiplicity_rows", toJson true), ("real_rows", Json.null)] + let bytes := (#[("bytes1", 3, 256), ("bytes2", 10, 65536)] : Array (String × Nat × Nat)) + |>.mapIdx fun index (name, width, height) => Json.mkObj [ + ("index", toJson (top.circuits.size + top.memorySizes.size + index)), + ("kind", toJson name), ("main_width", toJson width), ("fixed_height", toJson height), + ("canonical_seed_bytes", toJson (8 * width * height)), ("always_active", toJson true)] + pure <| Json.mkObj [ + ("program", toJson label), ("library_function_count", toJson top.functions.size), + ("constrained_function_count", toJson functions.size), + ("functions", Json.arr functions), + ("circuits", Json.arr <| top.circuits.mapIdx (circuitJson top names)), + ("primitive_circuits", Json.arr (memories ++ bytes))] + +def document (programs : Array Json) : Json := + Json.mkObj [ + ("schema_version", toJson (1 : Nat)), + ("field_modulus", toJson (toString gSize.toNat)), + ("seed_encoding", toJson "canonical_u64"), + ("compact_encoding", toJson "typed_schema_guarded"), + ("row_weights", Json.null), + ("programs", Json.arr programs)] + +end Aiur.TraceReport + +end diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean index ba47d9064..74d75a43b 100644 --- a/Ix/Cli/CodegenCmd.lean +++ b/Ix/Cli/CodegenCmd.lean @@ -31,6 +31,9 @@ public import Cli public import Ix.Aggr public import Ix.Aiur.Compiler public import Ix.Aiur.Stages.Codegen +public import Ix.Aiur.Stages.TraceReport +public import Ix.Aiur.Stages.TraceCodegen +public import Ix.Aiur.Stages.TraceCuda public import Ix.IxVM public import Ix.IxVM.Toplevel public import MultiStark @@ -47,6 +50,7 @@ structure Target where label : String source : Except Aiur.Global Aiur.Source.Toplevel outPath : String + groups : Array (String × Array String) def targets : List Target := [ -- the generated kernel is the kernel. Every consumer of @@ -54,14 +58,15 @@ def targets : List Target := [ -- table (CheckCmd / ProveCmd / VerifyCmd), or `funIdx` lookups -- resolve against a different function set than the generated code. { label := "ixvm", source := IxVM.ixVM, - outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs" }, + outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs", groups := IxVM.functionGroups }, { label := "multi-stark", source := MultiStark.multiStark, - outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs" }, + outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs", + groups := MultiStark.verifierFunctionGroups }, -- `ix aggregate` proving/verification must select the SAME toplevel for its -- function-index table (`Aggr.ixAggr`), or `ix_aggr` lookups resolve -- against a different function set than the generated code. { label := "ix-aggr", source := Aggr.ixAggr, - outPath := "crates/ixvm-codegen/src/aiur_ix_aggr.rs" } + outPath := "crates/ixvm-codegen/src/aiur_ix_aggr.rs", groups := Aggr.functionGroups } ] /-- Emit one target. In `--check` mode, compares against the on-disk file @@ -100,10 +105,156 @@ def emitTarget (checkOnly : Bool) (t : Target) : IO Bool := do ({compiled.bytecode.functions.size} aiur fns)" return true +def traceReportTarget (target : Target) : Except String Lean.Json := do + let source ← target.source.mapError fun error => s!"source error: {repr error}" + let compiled ← source.compile + -- Reports describe production grouping independent of the runtime override. + let grouped ← compiled.groupFunctions target.groups + TraceReport.program target.label grouped + +/-- Circuits generated beyond the static rule, by circuit name per target: +the IxVM circuits whose host trace building dominates a proof, small rows +in very large numbers whose typed seed is a fraction of the row. The list +was chosen from one environment's measurements; revisit it when a heavier +one is profiled. -/ +def weightedCircuits : List (String × Array String) := [ + ("ixvm", #[ + "blake3_compress_chunks", "get_tag4", "get_u64_le", "g_list_has", "list_snoc.G", + "expr_glb_walk", "expr_inst_many_walk", "get_app_telescope", "expr_glb", "expr_lower", + "get_expr", "expr_lbr", "k_infer_app_spine_loop", "list_drop.G", "expr_inst_many_bvar", + "expr_lower_walk", "bytes_to_block", "expr_inst_many", "get_expr_list", "collect_spine", + "list_concat.G", "apply_spine", "list_lookup.Ptr.KExprNode", "ixvm_group_24"])] + +/-- The production selection: `blake3_compress`, every circuit whose members +pack into at most half their canonical seeds +(`ProgramPlan.compactCircuitFunctions`), and the measured `weightedCircuits`. +Every selected writer is generated from the same bytecode library as its +host seed packer. -/ +def traceBundle : Except String (Array (String × String)) := do + let mut files := #[] + let mut units := #[] + for target in targets do + let source ← target.source.mapError fun error => s!"{target.label}: {repr error}" + let compiled ← source.compile + let grouped ← compiled.groupFunctions target.groups + let some function := compiled.getFuncIdx `blake3_compress + | throw s!"{target.label}: missing blake3_compress" + let plan ← (TracePlan.program grouped.bytecode).mapError fun error => s!"{target.label}: {error}" + let mut chosen := plan.compactCircuitFunctions.push function + -- A weighted name is a function (any of its aliases; its whole circuit + -- is taken) or a group circuit's name. + for name in (weightedCircuits.lookup target.label).getD #[] do + let circuit := match compiled.getFuncIdx (String.toName name) with + | some index => + grouped.bytecode.circuits.find? fun (c : Bytecode.Circuit) => c.members.contains index + | none => grouped.bytecode.circuits.find? fun (c : Bytecode.Circuit) => c.name == name + let some circuit := circuit + | throw s!"{target.label}: no function or circuit named {name} in the weighted selection" + chosen := chosen ++ circuit.members + let selected := some ((chosen.toList.eraseDups.toArray).qsort (· < ·)) + let unit := target.label.replace "-" "_" + let cuda ← TraceCuda.emit grouped.bytecode unit selected + let path := s!"cuda/generated/production/{unit}.cu" + let digest := (Blake3.Rust.hash cuda.toUTF8).val.data.map fun n => Lean.toJson n.toNat + units := units.push (Lean.Json.mkObj [("source", Lean.toJson path), ("digest", Lean.Json.arr digest)]) + files := files ++ #[ + (s!"crates/aiur/src/trace_codegen/programs/{unit}.rs", ← TraceCodegen.emit grouped.bytecode "crate" selected), + (s!"crates/aiur/src/trace_codegen/programs/{unit}_cuda.rs", ← TraceCuda.registry grouped.bytecode unit "crate" selected), + (s!"crates/aiur/{path}", cuda)] + let manifest := Lean.Json.mkObj [("abi", Lean.toJson (2 : Nat)), ("units", Lean.Json.arr units)] + pure (files.push ("crates/aiur/cuda/generated/production/trace-manifest.json", manifest.pretty ++ "\n")) + +def emitTraceBundle (checkOnly : Bool) : IO UInt32 := do + let files ← match traceBundle with + | .ok files => pure files + | .error error => IO.eprintln s!"trace bundle: {error}"; return 1 + for (path, source) in files do + if checkOnly then + let existing ← try pure (some (← IO.FS.readFile path)) catch _ => pure none + unless existing == some source do + IO.eprintln s!"{path} is missing or stale; run ix codegen --trace-bundle" + return 1 + else + if let some parent := (System.FilePath.mk path).parent then IO.FS.createDirAll parent + IO.FS.writeFile path source + IO.println s!"{path}: {source.utf8ByteSize} bytes" + return 0 + def runCodegenCmd (p : Cli.Parsed) : IO UInt32 := do let checkOnly := p.hasFlag "check" + let traceReport := p.hasFlag "trace-report" + let traceRust := p.hasFlag "trace-rust" + let traceCuda := p.hasFlag "trace-cuda" + let traceRegistry := p.hasFlag "trace-cuda-registry" + let bundle := p.hasFlag "trace-bundle" + if (#[checkOnly && !bundle, bundle, traceReport, traceRust, traceCuda, traceRegistry].filter id).size > 1 then + IO.eprintln "Select one codegen mode: --check, --trace-bundle [--check], --trace-report, --trace-rust, --trace-cuda, or --trace-cuda-registry" + return 1 + if bundle then + if p.hasFlag "target" || p.hasFlag "trace-functions" then + IO.eprintln "--trace-bundle emits the production selection for all three targets" + return 1 + return ← emitTraceBundle checkOnly + let selected ← match (p.flag? "target").map (·.as! String) with + | none => pure targets + | some label => + let selected := targets.filter (·.label == label) + if selected.isEmpty then + IO.eprintln s!"Unknown codegen target {label}; expected ixvm, multi-stark, or ix-aggr" + return 1 + pure selected + if traceCuda || traceRegistry then + let [target] := selected | do + IO.eprintln "CUDA emission requires one --target" + return 1 + let some functions := (p.flag? "trace-functions").map (·.as! String) | do + IO.eprintln "CUDA emission requires --trace-functions with comma-separated constrained function indices" + return 1 + let emitted : Except String String := do + let mut indices := #[] + for item in functions.splitOn "," do + let some index := item.trimAscii.toString.toNat? | throw s!"invalid function index {item}" + indices := indices.push index + let source ← target.source.mapError (fun error => s!"{repr error}") + let compiled ← source.compile + let grouped ← compiled.groupFunctions target.groups + let unit := target.label.replace "-" "_" + if traceCuda then Aiur.TraceCuda.emit grouped.bytecode unit (some indices) + else Aiur.TraceCuda.registry grouped.bytecode unit "aiur" (some indices) + match emitted with + | .ok source => IO.print source; return 0 + | .error error => IO.eprintln s!"{target.label} CUDA codegen: {error}"; return 1 + if traceRust then + let [target] := selected | do + IO.eprintln "--trace-rust requires one --target" + return 1 + let emitted : Except String String := do + let mut selected := none + if let some functions := (p.flag? "trace-functions").map (·.as! String) then + let mut indices := #[] + for item in functions.splitOn "," do + let some index := item.trimAscii.toString.toNat? | throw s!"invalid function index {item}" + indices := indices.push index + selected := some indices + let source ← target.source.mapError (fun error => s!"{repr error}") + let compiled ← source.compile + let grouped ← compiled.groupFunctions target.groups + Aiur.TraceCodegen.emit grouped.bytecode "aiur" selected + match emitted with + | .ok source => IO.print source; return 0 + | .error error => IO.eprintln s!"{target.label} trace codegen: {error}"; return 1 + if traceReport then + let mut reports := #[] + for target in selected do + match traceReportTarget target with + | .ok report => reports := reports.push report + | .error error => + IO.eprintln s!"{target.label} trace report: {error}" + return 1 + IO.println (TraceReport.document reports).compress + return 0 let mut ok := true - for t in targets do + for t in selected do ok := (← emitTarget checkOnly t) && ok return if ok then 0 else 1 @@ -115,7 +266,14 @@ def codegenCmd : Cli.Cmd := `[Cli| "Compile the IxVM kernel, MultiStark verifier, and single-entrypoint ixAggr system to Rust via the Bytecode → Rust codegen pass (fixed output paths, no override). PARITY UNVERIFIED — run their generated/interpreter fixture checks before trusting any witness." FLAGS: - "check"; "CI mode: compare all three emitted sources (`aiur_ixvm.rs`, `aiur_multi_stark.rs`, `aiur_ix_aggr.rs`) against disk and exit 0 if identical, 1 otherwise. Does not modify files." + "trace-bundle"; "Generate production CUDA units, host seed writers, and registry manifests for all three programs; --check detects stale files." + "check"; "Compare selected emitted Rust sources against disk and exit 0 if identical, 1 otherwise. Does not modify files." + "trace-cuda"; "Emit CUDA row writers for --trace-functions in one --target." + "trace-cuda-registry"; "Emit the Rust registry for the same CUDA function selection." + "trace-functions" : String; "Comma-separated constrained function indices from --trace-report; required for CUDA emission." + "trace-rust"; "Emit experimental scalar trace writers and read-only seed packers to stdout for one --target." + "trace-report"; "Print a static GPU trace-plan inventory as JSON, with production groups and explicit missing row weights. Does not write generated source." + "target" : String; "Select ixvm, multi-stark, or ix-aggr (default: all three)." ] end diff --git a/Tests/Aiur.lean b/Tests/Aiur.lean index dcdafc545..4c3000f87 100644 --- a/Tests/Aiur.lean +++ b/Tests/Aiur.lean @@ -3,6 +3,7 @@ module public import Tests.Aiur.Common public import Tests.Aiur.Aiur public import Tests.Aiur.Cost +public import Tests.Aiur.TracePlan public import Tests.Aiur.Hashes public import Tests.Aiur.RBTreeMap public import Tests.Aiur.Cross diff --git a/Tests/Aiur/TraceCodegen.lean b/Tests/Aiur/TraceCodegen.lean new file mode 100644 index 000000000..c0978222c --- /dev/null +++ b/Tests/Aiur/TraceCodegen.lean @@ -0,0 +1,172 @@ +module + +public import Ix.Aiur.Stages.TraceCodegen +public import Ix.Aiur.Compiler +public import Ix.IxVM.Toplevel + +public section + +namespace AiurTests.TraceCodegen + +open Aiur Aiur.Bytecode + +private def definition (inputs : Nat) (body : Block) (constrained : Bool := true) : Function := + let (_, state) := (Concrete.Bytecode.blockLayout body).run + (Concrete.Bytecode.LayoutMState.new inputs) + { body, entry := true, constrained, + layout := { state.functionLayout with lookups := state.functionLayout.lookups + 1 } } + +private def fields : Function := definition 2 { + ops := #[.add 0 1, .sub 0 1, .mul 0 1, .const 7, .mul 4 5, + .eqZero 6, .eqZero 0, .unconstrainedGInverse 0, .unconstrainedGToBytes 0], + ctrl := .return 0 #[] } + +private def bytes : Function := definition 2 { + ops := #[.u8BitDecomposition 0, .u8ShiftLeft 0, .u8ShiftRight 0, + .u8Xor 0 1, .u8Add 0 1, .u8Sub 0 1, .u8Mul 0 1, .u8And 0 1, + .u8Or 0 1, .u8LessThan 0 1, .u8XorSplit7 0 1, .u8XorSplit4 0 1, + .u8RangeCheck 0 1, .mul 14 16], + ctrl := .return 0 #[] } + +private def words : Function := definition 12 { + ops := #[.u32ToField #[0,1,2,3], .u32ToField #[4,5,6,7], .u32LessThan 12 13, + .unconstrainedU32Add #[0,1,2,3] #[4,5,6,7], + .unconstrainedU32Add3 #[0,1,2,3] #[4,5,6,7] #[8,9,10,11], .mul 19 24], + ctrl := .return 0 #[12,13,14,19,24] } + +private def branches : Function := definition 2 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.mul 1 1], ctrl := .yield 0 #[2] }), + (1, { ops := #[.u8Add 1 1], ctrl := .yield 1 #[2] })] + (some { ops := #[.eqZero 1], ctrl := .yield 2 #[2] }) + 1 4 1 { ops := #[.mul 2 1], ctrl := .return 3 #[3] } } + +private def memory : Function := definition 1 { + ops := #[.mul 0 0, .store #[0,1], .call 5 #[2] 1 false, .load 2 3, .add 4 5], + ctrl := .return 0 #[6] } + +private def identityFunction : Function := definition 1 { ops := #[], ctrl := .return 0 #[0] } + +private def aliasFunction : Function := definition 1 { + ops := #[.mul 0 0, .call 5 #[1] 1 false], ctrl := .return 0 #[2] } + +private def ioFunction : Function := definition 2 { + ops := #[.ioWrite 0 #[1], .ioGetInfo 0 #[1], .ioRead 0 2 2, + .const 999, .ioSetInfo 0 #[6] 2 3, .assertEq #[4] #[4] (some "quoted \"value\"\nλ"), + .debug "trace fixture" none], + ctrl := .return 0 #[4,5] } + +private def earlyReturn : Function := definition 1 { + ops := #[.mul 0 0], ctrl := .matchContinue 1 + #[(0, { ops := #[], ctrl := .return 0 #[] })] + (some { ops := #[], ctrl := .yield 1 #[] }) + 0 1 0 { ops := #[.load 1 0], ctrl := .return 2 #[] } } + +private def nestedEarlyReturn : Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[.mul 0 0] + ctrl := .match 1 + #[(0, { ops := #[], ctrl := .return 0 #[] })] + (some { ops := #[], ctrl := .yield 1 #[] }) })] + (some { ops := #[], ctrl := .yield 2 #[] }) + 0 2 0 { ops := #[.load 1 0], ctrl := .return 3 #[] } } + +private def branchReads : Function := definition 2 { + ops := #[.const 0], ctrl := .matchContinue 0 + #[(0, { ops := #[.ioRead 1 2 1], ctrl := .yield 0 #[3] })] + (some { ops := #[.ioRead 1 2 2], ctrl := .yield 1 #[4] }) + 1 3 0 { ops := #[.ioRead 1 3 1], ctrl := .return 2 #[4] } } + +private def bigUint : Function := definition 2 { + ops := #[.unconstrainedBigUintDivMod 0 1, .load 10 2], ctrl := .return 0 #[2,3] } + +private def constants : Function := definition 0 { + ops := #[.const 0, .eqZero 0, .const (G.ofNat (gSize.toNat - 1)), .eqZero 2], + ctrl := .return 0 #[] } + +private def unconstrainedFunction : Function := definition 1 { + ops := #[.unconstrainedGInverse 0], ctrl := .return 0 #[1] } false + +private def unconstrainedCaller : Function := definition 1 { + ops := #[.call 13 #[0] 1 true], ctrl := .return 0 #[1] } + +private def emptyCaller : Function := definition 1 { + ops := #[.mul 0 0, .call 16 #[] 0 false, .load 0 0, .ioRead 0 0 0], + ctrl := .return 0 #[] } + +private def emptyFunction : Function := definition 0 { ops := #[], ctrl := .return 0 #[] } + +private def nestedMergeRead : Function := definition 3 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[] + ctrl := .matchContinue 2 + #[(0, { ops := #[.const 0], ctrl := .yield 0 #[3] })] + (some { ops := #[.const 1], ctrl := .yield 1 #[3] }) + 1 1 0 { ops := #[.add 3 2], ctrl := .yield 2 #[4] } })] + (some { ops := #[.const 2], ctrl := .yield 3 #[3] }) + 1 2 0 { ops := #[.ioRead 1 3 1], ctrl := .return 4 #[4] } } + +private def exhaustiveMatch : Function := definition 1 { + ops := #[], ctrl := .match 0 #[(0, { ops := #[], ctrl := .return 0 #[] })] none } + +mutual + private partial def reindexBlock (oldIndex newIndex : Nat) (block : Block) : Except String Block := do + let ops ← block.ops.mapM fun op => match op with + | .call index args size unc => + if index != oldIndex then throw "BLAKE3 fixture gained an external callee" + else pure (.call newIndex args size unc) + | _ => pure op + pure { ops, ctrl := ← reindexControl oldIndex newIndex block.ctrl } + private partial def reindexControl (oldIndex newIndex : Nat) : Ctrl → Except String Ctrl + | .match d arms fallback => do + pure (.match d (← arms.mapM fun (v, b) => return (v, ← reindexBlock oldIndex newIndex b)) + (← fallback.mapM (reindexBlock oldIndex newIndex))) + | .matchContinue d arms fallback n aux lookups continuation => do + pure (.matchContinue d (← arms.mapM fun (v, b) => return (v, ← reindexBlock oldIndex newIndex b)) + (← fallback.mapM (reindexBlock oldIndex newIndex)) n aux lookups + (← reindexBlock oldIndex newIndex continuation)) + | ctrl => pure ctrl +end + +def fixtureProgram : Except String Toplevel := do + let mut functions := #[fields, bytes, words, branches, memory, identityFunction, + aliasFunction, ioFunction, earlyReturn, nestedEarlyReturn, branchReads, bigUint, + constants, unconstrainedFunction, unconstrainedCaller, emptyCaller, emptyFunction] + let source ← IxVM.ixVM.mapError (fun error => s!"{repr error}") + let compiled ← source.compile + let some index := compiled.getFuncIdx `blake3_compress | throw "missing BLAKE3 function" + let function := compiled.bytecode.functions[index]! + functions := functions.push { function with + entry := true + body := ← reindexBlock index functions.size function.body } + functions := functions ++ #[nestedMergeRead, exhaustiveMatch, definition 12 { + ops := #[.unconstrainedU32Add #[0,1,2,3] #[4,5,6,7], + .unconstrainedU32Add3 #[0,1,2,3] #[4,5,6,7] #[8,9,10,11], .mul 16 21], + ctrl := .return 0 #[16,21,22] }] + let some multiply := compiled.getFuncIdx `u64_mul | throw "missing u64_mul function" + functions := functions.push { compiled.bytecode.functions[multiply]! with entry := true } + let mut circuits := #[{ + name := "mixed", members := #[0, 3, 12], + layout := fields.layout.merge branches.layout |>.merge constants.layout : Circuit }] + for i in [:functions.size] do + if functions[i]!.constrained && !(#[0,3,12]).contains i then + circuits := circuits.push { name := s!"function_{i}", members := #[i], layout := functions[i]!.layout } + pure { functions, memorySizes := #[0,1,2,10], circuits } + +def blake3Program : Except String Bytecode.Toplevel := do + let top ← fixtureProgram + let function := top.functions[17]! + let body ← reindexBlock 17 0 function.body + let function := { function with body } + pure { + functions := #[function], memorySizes := #[], + circuits := #[{ name := "blake3", members := #[0], layout := function.layout }] } + +def emitFixtures : Except String String := do + Aiur.TraceCodegen.emit (← fixtureProgram) "crate" + +end AiurTests.TraceCodegen + +end diff --git a/Tests/Aiur/TraceFixtures.lean b/Tests/Aiur/TraceFixtures.lean new file mode 100644 index 000000000..c0e42e0d9 --- /dev/null +++ b/Tests/Aiur/TraceFixtures.lean @@ -0,0 +1,43 @@ +import Tests.Aiur.TraceCodegen +import Ix.Aiur.Stages.TraceCuda + +/-! Regenerates the trace-codegen test fixtures: for the planner's fixture +program and the BLAKE3 library, the Rust seed packers and row writers under +`crates/aiur/src/trace_codegen/tests/`, the CUDA units under +`crates/aiur/cuda/generated/`, and the manifest that binds them. `--check` +compares instead of writing, as `ix codegen --trace-bundle --check` does +for the production units. -/ + +def main (args : List String) : IO UInt32 := do + unless args.isEmpty || args == ["--check"] do + IO.eprintln "Expected no arguments or --check" + return 1 + let files : Except String (Array (String × String)) := do + let mut files := #[] + let mut units := #[] + for (unit, top) in #[("fixtures", ← AiurTests.TraceCodegen.fixtureProgram), + ("blake3", ← AiurTests.TraceCodegen.blake3Program)] do + let stem := if unit == "fixtures" then "generated" else "blake3" + let cuda ← Aiur.TraceCuda.emit top unit + let digest := (Blake3.Rust.hash cuda.toUTF8).val.data.map fun n => Lean.toJson n.toNat + let path := s!"cuda/generated/{unit}.cu" + units := units.push (Lean.Json.mkObj [("source", Lean.toJson path), ("digest", Lean.Json.arr digest)]) + files := files ++ #[ + (s!"crates/aiur/src/trace_codegen/tests/{stem}.rs", ← Aiur.TraceCodegen.emit top "crate"), + (s!"crates/aiur/src/trace_codegen/tests/{stem}_cuda.rs", ← Aiur.TraceCuda.registry top unit "crate"), + (s!"crates/aiur/{path}", cuda)] + let manifest := Lean.Json.mkObj [("abi", Lean.toJson (2 : Nat)), ("units", Lean.Json.arr units)] + pure (files.push ("crates/aiur/cuda/trace-manifest.json", manifest.pretty ++ "\n")) + let files ← match files with + | .ok files => pure files + | .error error => IO.eprintln error; return 1 + for (path, source) in files do + if args == ["--check"] then + if (← IO.FS.readFile path) != source then + IO.eprintln s!"{path} is stale" + return 1 + else + if let some parent := (System.FilePath.mk path).parent then IO.FS.createDirAll parent + IO.FS.writeFile path source + IO.println s!"{path}: {source.utf8ByteSize} bytes" + return 0 diff --git a/Tests/Aiur/TracePlan.lean b/Tests/Aiur/TracePlan.lean new file mode 100644 index 000000000..841cb6b3b --- /dev/null +++ b/Tests/Aiur/TracePlan.lean @@ -0,0 +1,406 @@ +module + +public import LSpec +public import Ix.Aiur.Stages.TraceReport + +public section + +open LSpec Aiur Aiur.Bytecode Aiur.TracePlan + +namespace AiurTests.TracePlan + +private def definition (inputs : Nat) (body : Bytecode.Block) : Bytecode.Function := + let (_, state) := (Concrete.Bytecode.blockLayout body).run + (Concrete.Bytecode.LayoutMState.new inputs) + { body, entry := false, constrained := true, + layout := { state.functionLayout with lookups := state.functionLayout.lookups + 1 } } + +private def singletonProgram (functions : Array Bytecode.Function) + (memorySizes : Array Nat := #[]) : Bytecode.Toplevel := + { functions, memorySizes, circuits := functions.mapIdx fun index f => + { name := s!"function_{index}", members := #[index], layout := f.layout } } + +private def accepts (name : String) (top : Bytecode.Toplevel) + (check : FunctionPlan → Bool) : TestSeq := + match Aiur.TracePlan.function top 0 with + | .ok plan => test name (check plan) + | .error error => test s!"{name}: {error}" false + +private def rejects (name : String) (top : Bytecode.Toplevel) : TestSeq := + test name ((match Aiur.TracePlan.program top with + | .error _ => true + | .ok _ => false) : Bool) + +private def arithmetic : Bytecode.Function := definition 2 { + ops := #[.mul 0 1, .const 7, .mul 2 3, .eqZero 4, .const 0, .eqZero 6, + .u8Add 0 1, .unconstrainedU32Add #[0, 1, 0, 1] #[1, 0, 1, 0], + .u32ToField #[10, 11, 12, 13]], + ctrl := .return 0 #[15] } + +private def identityFunction : Bytecode.Function := definition 1 { + ops := #[], ctrl := .return 0 #[0] } + +private def returnedCall : Bytecode.Function := definition 1 { + ops := #[.mul 0 0, .add 1 0, .call 1 #[2] 1 false], + ctrl := .return 0 #[3] } + +private def callThenLoad : Bytecode.Function := definition 1 { + ops := #[.mul 0 0, .call 1 #[1] 1 false, .load 2 2], + ctrl := .return 0 #[4] } + +private def branchBody (sharedAux : Nat := 4) (sharedLookups : Nat := 1) + (continuationInput : Nat := 2) : Bytecode.Block := { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.mul 1 1], ctrl := .yield 0 #[2] }), + (1, { ops := #[.u8Add 1 1], ctrl := .yield 1 #[2] })] + (some { ops := #[.eqZero 1], ctrl := .yield 2 #[2] }) + 1 sharedAux sharedLookups + { ops := #[.mul continuationInput 1], ctrl := .return 3 #[3] } } + +private def nested : Bytecode.Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[], ctrl := .yield 0 #[0] })] none 1 0 0 + { ops := #[], ctrl := .yield 1 #[1] } })] + (some { ops := #[.const 2], ctrl := .yield 2 #[1] }) + 1 1 0 { ops := #[], ctrl := .return 3 #[1] } } + +private def earlyReturn : Bytecode.Function := definition 1 { + ops := #[.mul 0 0], ctrl := .matchContinue 1 + #[(0, { ops := #[], ctrl := .return 0 #[0] })] + (some { ops := #[], ctrl := .yield 1 #[] }) + 0 1 0 { ops := #[.load 1 0], ctrl := .return 2 #[2] } } + +private def branchReads : Bytecode.Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.ioRead 0 0 1], ctrl := .yield 0 #[1] })] + (some { ops := #[.ioRead 0 0 2], ctrl := .yield 1 #[2] }) + 1 3 0 { ops := #[.ioRead 0 1 1], ctrl := .return 2 #[2] } } + +private def nestedEarlyReturn : Bytecode.Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[.mul 0 0], ctrl := .match 1 + #[(0, { ops := #[], ctrl := .return 0 #[0] })] + (some { ops := #[], ctrl := .yield 1 #[] }) })] + (some { ops := #[], ctrl := .yield 2 #[] }) + 0 2 0 { ops := #[.load 1 0], ctrl := .return 3 #[1] } } + +private def externalReads : Bytecode.Function := definition 1 { + ops := #[.store #[0], .load 1 1, .ioGetInfo 0 #[2], .ioRead 0 3 2, + .unconstrainedBigUintDivMod 1 2, .ioSetInfo 0 #[2] 3 4, .ioWrite 0 #[5, 6]], + ctrl := .return 0 #[7, 8] } + +private def grouped : Bytecode.Toplevel := { + functions := #[arithmetic, nested], memorySizes := #[], + circuits := #[{ + name := "group", members := #[0, 1], + layout := arithmetic.layout.merge nested.layout }] } + +private def hasBackwardDependencies (plan : FunctionPlan) : Bool := + (plan.values.mapIdx fun index value => + value.rowInputs.all (· < index) && value.preparationInputs.all (· < index)).all id + +def allocationTests : TestSeq := + accepts "degree-sensitive allocations and virtual carries" + (singletonProgram #[arithmetic]) (fun plan => + plan.layout.auxiliaries == 9 && plan.layout.lookups == 2 && + plan.operations.map (·.auxiliaries) == + #[⟨1, 1⟩, ⟨2, 0⟩, ⟨2, 0⟩, ⟨2, 2⟩, ⟨4, 0⟩, ⟨4, 0⟩, + ⟨4, 1⟩, ⟨5, 4⟩, ⟨9, 0⟩] && + plan.operations.map (·.outputs.size) == #[1, 1, 1, 1, 1, 1, 2, 5, 1]) ++ + accepts "unused auxiliary writes survive but virtual return expressions need no row work" + (singletonProgram #[arithmetic]) (fun plan => + plan.rowOperations == #[0, 1, 2, 3, 6, 7] && + plan.preparationOperations.isEmpty && plan.seedWords == 3) ++ + accepts "short branches reserve the maximum including default inverses" + (singletonProgram #[definition 2 (branchBody 4)]) (fun plan => + plan.layout.auxiliaries == 7 && plan.layout.lookups == 2 && + plan.layout.selectors == 4 && + plan.operations.map (·.auxiliaries) == #[⟨1, 1⟩, ⟨1, 1⟩, ⟨3, 2⟩, ⟨6, 1⟩] && + match plan.body.control with + | .continueWith _ _ _ inverses space merges columns _ => + inverses == ⟨1, 2⟩ && space.auxiliaries == ⟨1, 4⟩ && + space.lookups == ⟨1, 1⟩ && columns == ⟨5, 1⟩ && merges == #[6] + | _ => false) ++ + accepts "nested continuations consume their own yields and preserve the outer scope" + (singletonProgram #[nested]) (fun plan => + plan.layout.auxiliaries == 3 && plan.layout.selectors == 4 && + hasBackwardDependencies plan && + match plan.body.control with + | .continueWith _ _ _ _ _ merges columns _ => merges == #[3] && columns == ⟨2, 1⟩ + | _ => false) ++ + rejects "incorrect shared auxiliary reservation is rejected" + (singletonProgram #[definition 2 (branchBody 3)]) ++ + rejects "incorrect shared lookup reservation is rejected" + (singletonProgram #[definition 2 (branchBody 4 0)]) ++ + rejects "continuation cannot refer to a discarded branch local" + (singletonProgram #[definition 2 (branchBody 4 1 3)]) + +def preparationTests : TestSeq := + accepts "returned-call alias skips key arithmetic but retains strict-check dependencies" + (singletonProgram #[returnedCall, identityFunction]) (fun plan => + plan.seedWords == 3 && plan.preparationOperations == #[2] && + plan.aliasCheckOperations == #[0, 1, 2] && plan.rowOperations == #[0, 2] && + plan.operations.filterMap (fun op => op.externalRead.map (·.kind)) == + #[.returnedCall 1]) ++ + accepts "call-result-to-load chain retains CPU key arithmetic" + (singletonProgram #[callThenLoad, identityFunction] #[2]) (fun plan => + plan.seedWords == 5 && plan.preparationOperations == #[0, 1, 2] && + plan.operations.filterMap (fun op => op.externalRead.map (·.kind)) == + #[.callResult 1, .loadValues 2] && + plan.operations.filterMap (fun op => op.externalRead.map (·.seed)) == + #[⟨2, 1⟩, ⟨3, 2⟩]) ++ + accepts "early return retains the branch decision guarding a continuation read" + (singletonProgram #[earlyReturn] #[1]) (fun plan => + plan.preparationOperations == #[0, 1] && plan.seedWords == 3) ++ + accepts "nested return retains its decision guarding an enclosing continuation read" + (singletonProgram #[nestedEarlyReturn] #[1]) (fun plan => + plan.preparationOperations == #[0, 1] && plan.seedWords == 3) ++ + accepts "branch seed slots overlap and continuation starts after the larger arm" + (singletonProgram #[branchReads]) (fun plan => + plan.seedWords == 5 && hasBackwardDependencies plan && + plan.operations.filterMap (fun op => op.externalRead.map (·.seed)) == + #[⟨2, 1⟩, ⟨2, 2⟩, ⟨4, 1⟩]) ++ + accepts "store, load, IO and BigUint are reads; execution-only effects have no seed" + (singletonProgram #[externalReads] #[1]) (fun plan => + plan.seedWords == 10 && plan.preparationOperations == #[0, 1, 2, 3, 4] && + plan.operations.filterMap (fun op => op.externalRead.map (·.kind)) == + #[.storePointer 1, .loadValues 1, .ioInfo, .ioValues 2, .bigUintResults]) ++ + accepts "zero-output calls allocate a lookup without a seed or a key recomputation" + (singletonProgram #[ + definition 1 { ops := #[.mul 0 0, .call 1 #[1] 0 false], ctrl := .return 0 #[] }, + definition 1 { ops := #[], ctrl := .return 0 #[] }]) (fun plan => + plan.layout.lookups == 2 && plan.seedWords == 2 && + plan.preparationOperations.isEmpty && plan.rowOperations == #[0]) ++ + accepts "unconstrained call results need advice but no call lookup" + (singletonProgram #[ + definition 1 { ops := #[.call 1 #[0] 1 true], ctrl := .return 0 #[1] }, + identityFunction]) (fun plan => + plan.layout.lookups == 1 && plan.layout.auxiliaries == 2 && plan.seedWords == 3) ++ + accepts "129 inputs and 32 aliased outputs have the BLAKE3 seed-word count" + (singletonProgram #[definition 129 { + ops := #[.call 0 (Array.range 129) 32 false], + ctrl := .return 0 (Array.range' 129 32) }]) (fun plan => + plan.seedWords == 162 && plan.canonicalSeedBytes == 1296) + +private def programPlan (top : Bytecode.Toplevel) (index : Nat) : Option FunctionPlan := + match Aiur.TracePlan.program top with + | .ok plan => plan.functions[index]?.join + | .error _ => none + +private def widths (plan : FunctionPlan) : Array SeedWidth := plan.seedSchema.widths + +private def exhaustiveThenFallback : Bytecode.Function := definition 2 { + ops := #[], ctrl := .match 0 + #[(0, { ops := #[], ctrl := .return 0 #[] }), + (300, { + ops := #[], ctrl := .match 1 + #[(1, { ops := #[], ctrl := .return 1 #[] })] + (some { ops := #[], ctrl := .return 2 #[] }) })] none } + +private def yieldsIntoByteUse : Bytecode.Function := definition 2 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[], ctrl := .yield 0 #[1] })] + (some { ops := #[.const 5], ctrl := .yield 1 #[2] }) + 1 1 0 { ops := #[.u8Xor 2 2], ctrl := .return 2 #[3] } } + +private def recursiveBytes : Bytecode.Function := definition 2 { + ops := #[], ctrl := .match 0 + #[(7, { ops := #[.u8Xor 1 1], ctrl := .return 0 #[2] })] + (some { ops := #[.const 1, .add 0 2, .call 0 #[3, 1] 1 false], ctrl := .return 1 #[4] }) } + +private def boundedArithmetic : Bytecode.Function := definition 1 { + ops := #[.u8Xor 0 0, .const 200, .add 1 2, .mul 3 3, .mul 4 4], + ctrl := .return 0 #[3, 4, 5] } + +private def callsBoundedArithmetic : Bytecode.Function := definition 1 { + ops := #[.call 1 #[0] 3 false], ctrl := .return 0 #[1, 2, 3] } + +private def byteIdentity : Bytecode.Function := definition 1 { + ops := #[.u8Xor 0 0], ctrl := .return 0 #[1] } + +private def callsByteIdentity : Bytecode.Function := definition 1 { + ops := #[.call 1 #[0] 1 false, .mul 1 1], ctrl := .return 0 #[2] } + +private def callsUnconstrained : Bytecode.Function := definition 1 { + ops := #[.call 1 #[0] 1 true], ctrl := .return 0 #[1] } + +/-- Singleton circuits for the constrained functions only. -/ +private def library (functions : Array Bytecode.Function) : Bytecode.Toplevel := + { functions, memorySizes := #[], + circuits := (functions.zipIdx.filter (·.1.constrained)).map fun (f, index) => + { name := s!"function_{index}", members := #[index], layout := f.layout } } + +private def programWidths (name : String) (functions : Array Bytecode.Function) + (expected : Array SeedWidth) (bytes : Nat) (memorySizes : Array Nat := #[]) : TestSeq := + test name ((match programPlan { library functions with memorySizes } 0 with + | some plan => widths plan == expected && plan.typedSeedBytes == bytes + | none => false) : Bool) + +/-- Stores a byte and a field element, then loads the pair back. -/ +private def storeThenLoad : Bytecode.Function := definition 2 { + ops := #[.u8Xor 0 0, .store #[2, 1], .load 2 3], ctrl := .return 0 #[4, 5] } + +/-- Loads from a table nothing in the library stores into. -/ +private def loadUnstored : Bytecode.Function := definition 1 { + ops := #[.load 2 0], ctrl := .return 0 #[1, 2] } + +/-- Stores a wide value into the slot another function stores a byte into. -/ +private def storeWide : Bytecode.Function := definition 1 { + ops := #[.store #[0, 0]], ctrl := .return 0 #[1] } + +/-- Loads through a continuation merge of input 1, after an arm-local +constant, so the pointer's bytecode index (2) is not its value id (3). -/ +private def loadThroughMerge : Bytecode.Function := definition 2 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.const 7], ctrl := .yield 0 #[1] })] + (some { ops := #[], ctrl := .yield 1 #[1] }) + 1 1 0 { ops := #[.load 1 2], ctrl := .return 2 #[3] } } + +def schemaTests : TestSeq := + test "typed layout stores wider words first, aligned, padded to eight" + (let schema := SeedSchema.ofWidths #[.full, .u8, .u32, .u16, .full, .u8] + schema.offsets == #[0, 22, 16, 20, 8, 23] && schema.bytes == 24) ++ + test "an all-full schema is the canonical encoding" + ((SeedSchema.canonical 3).isCanonical && (SeedSchema.canonical 3).bytes == 24) ++ + accepts "byte operations narrow the inputs they consume" + (singletonProgram #[arithmetic]) (fun plan => + widths plan == #[.full, .u8, .u8] && plan.typedSeedBytes == 16) ++ + accepts "an exhaustive match bounds its discriminant, a fallback does not" + (singletonProgram #[exhaustiveThenFallback]) (fun plan => + widths plan == #[.full, .u16, .full] && plan.typedSeedBytes == 24) ++ + accepts "a byte use on one arm speculatively narrows the word on every arm" + (singletonProgram #[definition 2 (branchBody 4)]) (fun plan => + widths plan == #[.full, .full, .u8]) ++ + accepts "continuation uses bound the values every arm yields" + (singletonProgram #[yieldsIntoByteUse]) (fun plan => + widths plan == #[.full, .full, .u8]) ++ + -- The callee's byte use narrows the argument; 255 + 200 < 2^16, its square + -- is below 2^32, and the square of that is wide. + programWidths "constants and byte results bound sums and products through call results" + #[callsBoundedArithmetic, boundedArithmetic] #[.full, .u8, .u16, .u32, .full] 24 ++ + programWidths "call results take callee output bounds and arguments take callee input bounds" + #[callsByteIdentity, byteIdentity] #[.full, .u8, .u8] 16 ++ + programWidths "recursive returns reach the least fixpoint instead of staying wide" + #[recursiveBytes] #[.full, .full, .u8, .u8] 24 ++ + programWidths "unconstrained callees contribute no bounds" + #[callsUnconstrained, { byteIdentity with constrained := false }] #[.full, .full, .full] 24 ++ + -- Seed: multiplicity, the two inputs, the store pointer, the two loaded words. + programWidths "loads take the join of every store into their table; pointers are u32" + #[storeThenLoad] #[.full, .u8, .full, .u32, .u8, .full] 32 #[2] ++ + programWidths "a wide store elsewhere in the library widens the loaded slot" + #[storeThenLoad, storeWide] #[.full, .u8, .full, .u32, .full, .full] 40 #[2] ++ + programWidths "a table with no store site loads unknown values but its pointer is u32" + #[loadUnstored] #[.full, .u32, .full, .full] 32 #[2] ++ + programWidths "pointer bounds follow resolved operands through merges" + #[loadThroughMerge] #[.full, .full, .u32, .full] 32 #[1] + +def malformedTests : TestSeq := + rejects "invalid value index" + (singletonProgram #[definition 1 { ops := #[.mul 0 1], ctrl := .return 0 #[1] }]) ++ + rejects "invalid callee index" + (singletonProgram #[definition 1 { ops := #[.call 9 #[0] 1 false], ctrl := .return 0 #[1] }]) ++ + rejects "callee input arity mismatch" + (singletonProgram #[definition 1 { + ops := #[.call 1 #[] 1 false], ctrl := .return 0 #[1] }, identityFunction]) ++ + rejects "callee output arity mismatch" + (singletonProgram #[definition 1 { + ops := #[.call 1 #[0] 2 false], ctrl := .return 0 #[1, 2] }, identityFunction]) ++ + rejects "memory read without its table" + (singletonProgram #[definition 1 { ops := #[.load 2 0], ctrl := .return 0 #[1, 2] }]) ++ + rejects "u32 operands must have four bytes" + (singletonProgram #[definition 1 { + ops := #[.unconstrainedU32Add #[0] #[0, 0, 0, 0]], ctrl := .return 0 #[1] }]) ++ + rejects "yield cannot escape a function" + (singletonProgram #[definition 1 { ops := #[], ctrl := .yield 0 #[0] }]) ++ + rejects "yield arity must match its continuation" + (singletonProgram #[definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[], ctrl := .yield 0 #[] })] none 1 0 0 + { ops := #[], ctrl := .return 1 #[1] } }]) ++ + rejects "duplicate selector allocation" + (singletonProgram #[definition 1 { + ops := #[], ctrl := .match 0 #[(0, { ops := #[], ctrl := .return 0 #[0] })] + (some { ops := #[], ctrl := .return 0 #[0] }) }]) ++ + rejects "selector outside the declared region" + (singletonProgram #[definition 1 { ops := #[], ctrl := .return 1 #[0] }]) ++ + rejects "duplicate match cases" + (singletonProgram #[definition 1 { + ops := #[], ctrl := .match 0 + #[(0, { ops := #[], ctrl := .return 0 #[0] }), + (0, { ops := #[], ctrl := .return 1 #[0] })] none }]) + +def groupingTests : TestSeq := + test "grouped functions retain member plans and merge only circuit regions" + ((match Aiur.TracePlan.program grouped with + | .error _ => false + | .ok plan => plan.functions.size == 2 && grouped.circuits[0]!.layout == + { inputSize := 2, selectors := 5, auxiliaries := 9, lookups := 2 }) : Bool) ++ + rejects "missing constrained member" { grouped with circuits := #[] } ++ + rejects "duplicate circuit member" { grouped with + circuits := grouped.circuits ++ grouped.circuits } ++ + rejects "declared circuit layout must match its members" { grouped with + circuits := #[{ grouped.circuits[0]! with layout := arithmetic.layout }] } ++ + rejects "unconstrained function cannot be a circuit member" { grouped with + functions := #[{ arithmetic with constrained := false }, nested] } + +private def reportFixture (reverseAliases : Bool) : Except String Lean.Json := + let names : List (Global × Nat) := [(⟨`z_alias⟩, 0), (⟨`a_alias⟩, 0), (⟨`nested⟩, 1)] + Aiur.TraceReport.program "fixture" { + source := ⟨#[], #[], #[]⟩, bytecode := grouped, + nameMap := .ofList (if reverseAliases then names.reverse else names) } + +private def reportShapes : Except String Bool := do + let report ← reportFixture false + let circuits ← (← report.getObjVal? "circuits").getArr? + let some circuit := circuits[0]? | throw "missing grouped circuit" + let members ← (← circuit.getObjVal? "members").getArr? + let some first := members[0]? | throw "missing first member" + let some second := members[1]? | throw "missing second member" + let firstSelector ← (← first.getObjVal? "selector_base").getNat? + let secondSelector ← (← second.getObjVal? "selector_base").getNat? + let firstAuxiliary ← (← first.getObjVal? "auxiliary_base").getNat? + let secondAuxiliary ← (← second.getObjVal? "auxiliary_base").getNat? + let unknownRows := match ← circuit.getObjVal? "real_rows" with + | .null => true + | _ => false + let bytes ← (← report.getObjVal? "primitive_circuits").getArr? + let some bytes1 := bytes[0]? | throw "missing bytes1" + let some bytes2 := bytes[1]? | throw "missing bytes2" + let height1 ← (← bytes1.getObjVal? "fixed_height").getNat? + let height2 ← (← bytes2.getObjVal? "fixed_height").getNat? + let active1 ← (← bytes1.getObjVal? "always_active").getBool? + let active2 ← (← bytes2.getObjVal? "always_active").getBool? + pure (firstSelector == 2 && secondSelector == 3 && + firstAuxiliary == 7 && secondAuxiliary == 7 && unknownRows && + height1 == 256 && height2 == 65536 && active1 && active2) + +private def oneSelectorMatchIsBranchless : Except String Bool := do + let top := singletonProgram #[definition 1 { + ops := #[], ctrl := .match 0 + #[(0, { ops := #[], ctrl := .match 0 #[] none })] + (some { ops := #[], ctrl := .return 0 #[0] }) }] + let report ← Aiur.TraceReport.program "fixture" { + source := ⟨#[], #[], #[]⟩, bytecode := top, nameMap := {} } + let circuits ← (← report.getObjVal? "circuits").getArr? + let some circuit := circuits[0]? | throw "missing circuit" + (← circuit.getObjVal? "branchless").getBool? + +def reportTests : TestSeq := + test "report ordering is independent of alias-map insertion order" + ((match reportFixture false, reportFixture true with + | .ok left, .ok right => left.compress == right.compress + | _, _ => false) : Bool) ++ + test "report has group offsets, unknown weights and mandatory byte-table heights" + ((match reportShapes with | .ok valid => valid | .error _ => false) : Bool) ++ + test "one-selector match with an empty arm is not branchless" + ((match oneSelectorMatchIsBranchless with | .ok branchless => !branchless | .error _ => false) : Bool) + +def tests : TestSeq := allocationTests ++ preparationTests ++ schemaTests ++ + malformedTests ++ groupingTests ++ reportTests + +end AiurTests.TracePlan + +end diff --git a/Tests/Main.lean b/Tests/Main.lean index 7e8f31335..da3bb15ea 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -115,6 +115,7 @@ def primarySuites : Std.HashMap String (List LSpec.TestSeq) := .ofList [ ("ground-unit", Tests.Ground.suite), ("aiur-cross", [AiurTests.Cross.tests]), ("aiur-cost", [AiurTests.Cost.tests]), + ("aiur-trace-plan", [AiurTests.TracePlan.tests]), ("prim-addrs", Tests.Ix.Kernel.PrimAddrs.suite), ("primitive-address-parity", Tests.Ix.Kernel.BuildPrimitives.paritySuite ++ Tests.Ix.Kernel.BuildPrimOrigs.paritySuite), diff --git a/crates/aiur/build.rs b/crates/aiur/build.rs new file mode 100644 index 000000000..d14c6d633 --- /dev/null +++ b/crates/aiur/build.rs @@ -0,0 +1,300 @@ +//! CUDA build isolation. +//! +//! This build script is deliberately a no-op unless Cargo enables the +//! `cuda` feature. Normal CPU builds therefore need neither nvcc nor CUDA +//! headers/libraries. + +use std::env; +use std::path::{Path, PathBuf}; +use std::process::Command; + +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + println!("cargo:rerun-if-env-changed=NVCC"); + println!("cargo:rerun-if-env-changed=CUDA_HOME"); + println!("cargo:rerun-if-env-changed=CUDA_PATH"); + println!("cargo:rerun-if-env-changed=MULTI_STARK_CUDA_ARCHS"); + + if env::var_os("CARGO_FEATURE_CUDA").is_none() { + return; + } + + assert_eq!( + env::var("CARGO_CFG_TARGET_OS").as_deref(), + Ok("linux"), + "the first-party CUDA backend currently supports Linux targets only" + ); + assert_eq!( + env::var("CARGO_CFG_TARGET_ARCH").as_deref(), + Ok("x86_64"), + "the first-party CUDA backend currently supports x86_64 targets only" + ); + + let nvcc = nvcc_path(); + let out_dir = + PathBuf::from(env::var_os("OUT_DIR").expect("Cargo did not set OUT_DIR")); + let library = out_dir.join("libaiur_trace_cuda.a"); + let architectures = cuda_architectures(&nvcc); + + // Every aiur CUDA source belongs to the generated trace writers; the bare + // `cuda` feature only enables multi-stark's device backend. + if env::var_os("CARGO_FEATURE_CUDA_TRACE_CODEGEN").is_none() { + return; + } + let include = env::var_os("DEP_MULTI_STARK_CUDA_INCLUDE") + .expect("cuda-trace-codegen requires multi-stark's shared CUDA field header metadata"); + let includes = vec![PathBuf::from("cuda"), PathBuf::from(&include)]; + let headers = [ + PathBuf::from("cuda/trace_runtime.cuh"), + PathBuf::from("cuda/trace_primitives.cuh"), + PathBuf::from(include).join("goldilocks.cuh"), + ]; + let mut sources = vec![PathBuf::from("cuda/trace_runtime.cu")]; + { + for manifest_path in [ + "cuda/trace-manifest.json", + "cuda/generated/production/trace-manifest.json", + ] { + println!("cargo:rerun-if-changed={manifest_path}"); + let manifest: serde_json::Value = serde_json::from_slice( + &std::fs::read(manifest_path).expect("missing trace manifest"), + ) + .expect("invalid trace manifest"); + assert_eq!( + manifest["abi"].as_u64(), + Some(2), + "unsupported trace manifest ABI" + ); + for unit in manifest["units"].as_array().expect("manifest units") { + let path = + PathBuf::from(unit["source"].as_str().expect("CUDA unit source")); + assert!( + path + .components() + .all(|c| matches!(c, std::path::Component::Normal(_))) + && path.starts_with("cuda/generated") + && path.extension().is_some_and(|e| e == "cu"), + "CUDA unit path must be inside cuda/generated" + ); + let bytes = std::fs::read(&path).expect("missing generated CUDA unit"); + let digest: Vec = serde_json::from_value(unit["digest"].clone()) + .expect("CUDA unit digest"); + assert_eq!( + blake3::hash(&bytes).as_bytes().as_slice(), + digest, + "generated CUDA unit differs from its manifest: {}", + path.display() + ); + assert!(!sources.contains(&path), "duplicate CUDA unit"); + sources.push(path); + } + } + } + let mut common = vec![ + "--std=c++17".to_owned(), + "--cudart=static".to_owned(), + "--default-stream=per-thread".to_owned(), + "-O3".to_owned(), + "-lineinfo".to_owned(), + "--compiler-options=-fPIC".to_owned(), + "--ptxas-options=-v".to_owned(), + ]; + for architecture in &architectures { + common.push(format!( + "-gencode=arch=compute_{architecture},code=sm_{architecture}" + )); + } + // Exact-architecture cubins avoid PTX newer than the installed driver. + let version = Command::new(&nvcc) + .arg("--version") + .output() + .expect("failed to query nvcc version"); + assert!(version.status.success(), "nvcc --version failed"); + let mut key = blake3::Hasher::new(); + key.update(&version.stdout); + key.update(nvcc.as_encoded_bytes()); + for arg in &common { + key.update(arg.as_bytes()); + key.update(&[0]); + } + for include in &includes { + key.update(include.as_os_str().as_encoded_bytes()); + key.update(&[0]); + } + for header in &headers { + println!("cargo:rerun-if-changed={}", header.display()); + key.update(&std::fs::read(header).expect("missing CUDA header")); + } + let mut objects = Vec::new(); + for source in sources { + println!("cargo:rerun-if-changed={}", source.display()); + let mut hash = key.clone(); + hash.update(&std::fs::read(&source).expect("missing CUDA source")); + let object = out_dir.join(format!("{}.o", hash.finalize().to_hex())); + if !object.is_file() { + let mut command = Command::new(&nvcc); + command.args(&common); + for include in &includes { + command.arg("-I").arg(include); + } + command.arg("-c").arg(&source).arg("-o").arg(&object); + let output = command.output().expect("failed to execute nvcc"); + std::io::Write::write_all(&mut std::io::stderr(), &output.stderr) + .unwrap(); + if !output.status.success() { + let _ = std::fs::remove_file(&object); + panic!("nvcc failed for {}: {}", source.display(), output.status); + } + } + objects.push(object); + } + let _ = std::fs::remove_file(&library); + let status = Command::new(&nvcc) + .arg("--lib") + .arg("-o") + .arg(&library) + .args(&objects) + .status() + .expect("failed to archive CUDA objects"); + assert!(status.success(), "nvcc archive failed: {status}"); + + println!("cargo:rustc-link-search=native={}", out_dir.display()); + println!("cargo:rustc-link-lib=static=aiur_trace_cuda"); + // Bundle the CUDA runtime into Rust staticlib consumers as well as normal + // Cargo binaries. Dynamic native dependencies are not propagated through + // a Rust staticlib to a foreign final linker (for example, Lean/Lake), + // which otherwise leaves the CUDA registration and runtime symbols + // unresolved. This remains entirely behind the `cuda` feature. + println!("cargo:rustc-link-lib=static=cudart_static"); + println!("cargo:rustc-link-lib=dylib=dl"); + println!("cargo:rustc-link-lib=dylib=rt"); + println!("cargo:rustc-link-lib=dylib=pthread"); + println!("cargo:rustc-link-lib=dylib=stdc++"); + + for directory in cuda_library_directories(&nvcc) { + if directory.is_dir() { + println!("cargo:rustc-link-search=native={}", directory.display()); + } + } +} + +fn nvcc_path() -> std::ffi::OsString { + if let Some(nvcc) = env::var_os("NVCC") { + return nvcc; + } + if let Some(root) = + env::var_os("CUDA_HOME").or_else(|| env::var_os("CUDA_PATH")) + { + let candidate = PathBuf::from(root).join("bin/nvcc"); + if candidate.is_file() { + return candidate.into_os_string(); + } + } + "nvcc".into() +} + +fn cuda_architectures(nvcc: &std::ffi::OsStr) -> Vec { + let supported = supported_architectures(nvcc); + let configured = env::var("MULTI_STARK_CUDA_ARCHS").ok().map_or_else( + || { + let preferred = ["80", "86", "89", "90", "100", "120"]; + let selected = preferred + .into_iter() + .filter(|architecture| { + supported.iter().any(|item| item == architecture) + }) + .collect::>(); + let defaults = if selected.is_empty() { + detect_nvidia_architectures().unwrap_or_else(|| "80".to_owned()) + } else { + selected.join(",") + }; + (defaults, false) + }, + |value| (value, true), + ); + let (configured, explicitly_configured) = configured; + let architectures: Vec<_> = configured + .split(',') + .map(str::trim) + .filter(|architecture| !architecture.is_empty()) + .map(|architecture| { + assert!( + (2..=3).contains(&architecture.len()) + && architecture.chars().all(|character| character.is_ascii_digit()), + "invalid CUDA architecture {architecture:?}; expected comma-separated numbers such as 80,90" + ); + assert!( + !explicitly_configured + || supported.is_empty() + || supported.iter().any(|item| item == architecture), + "nvcc does not support CUDA architecture sm_{architecture}" + ); + architecture.to_owned() + }) + .collect(); + assert!( + !architectures.is_empty(), + "MULTI_STARK_CUDA_ARCHS must contain at least one architecture" + ); + architectures +} + +fn supported_architectures(nvcc: &std::ffi::OsStr) -> Vec { + let Ok(output) = Command::new(nvcc).arg("--list-gpu-code").output() else { + return Vec::new(); + }; + if !output.status.success() { + return Vec::new(); + } + String::from_utf8_lossy(&output.stdout) + .split_whitespace() + .filter_map(|code| code.strip_prefix("sm_")) + .filter(|code| code.chars().all(|character| character.is_ascii_digit())) + .map(str::to_owned) + .collect() +} + +/// Detect the architecture of the installed GPU when building on the target +/// machine. This avoids requiring users to translate `nvidia-smi`'s `12.0` +/// compute capability into nvcc's `sm_120` spelling. Cross builds and hosts +/// without a visible GPU retain the portable sm_80 default and can still set +/// `MULTI_STARK_CUDA_ARCHS` explicitly. +fn detect_nvidia_architectures() -> Option { + let output = Command::new("nvidia-smi") + .args(["--query-gpu=compute_cap", "--format=csv,noheader"]) + .output() + .ok()?; + if !output.status.success() { + return None; + } + let capabilities = String::from_utf8(output.stdout).ok()?; + let mut architectures = capabilities + .lines() + .map(|capability| { + capability + .chars() + .filter(|character| character.is_ascii_digit()) + .collect::() + }) + .filter(|architecture| !architecture.is_empty()) + .collect::>(); + architectures.sort_unstable(); + architectures.dedup(); + (!architectures.is_empty()).then(|| architectures.join(",")) +} + +fn cuda_library_directories(nvcc: &std::ffi::OsStr) -> Vec { + let root = env::var_os("CUDA_HOME") + .or_else(|| env::var_os("CUDA_PATH")) + .map(PathBuf::from) + .or_else(|| { + let nvcc = Path::new(nvcc); + nvcc + .is_absolute() + .then(|| nvcc.parent()?.parent().map(Path::to_path_buf)) + .flatten() + }) + .unwrap_or_else(|| PathBuf::from("/usr/local/cuda")); + vec![root.join("lib64"), root.join("targets/x86_64-linux/lib")] +} diff --git a/crates/aiur/cuda/generated/blake3.cu b/crates/aiur/cuda/generated/blake3.cu new file mode 100644 index 000000000..7ca7ac7f3 --- /dev/null +++ b/crates/aiur/cuda/generated/blake3.cu @@ -0,0 +1,1649 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_blake3 { +using namespace aiur_trace; + +__device__ __constant__ uint64_t inverse_0_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_blake3_0 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_blake3_0(Seed_blake3_0 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_0_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_blake3_0(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_blake3_0 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_blake3_0(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_blake3_0(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_blake3_0<<>>(seeds, real, rows, layout, output, error); + else kernel_blake3_0<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_blake3_0(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_blake3_0); +} + +extern "C" const uint8_t* aiur_trace_blake3_contract() { + static const uint8_t hash[32] = {150, 101, 248, 224, 67, 209, 56, 216, 146, 162, 51, 114, 82, 15, 10, 181, 15, 234, 113, 117, 51, 141, 70, 70, 235, 90, 62, 221, 45, 109, 215, 133}; + return hash; +} +extern "C" const uint8_t* aiur_trace_blake3_schema() { + static const uint8_t hash[32] = {165, 236, 59, 122, 69, 236, 212, 8, 235, 101, 210, 121, 79, 173, 18, 133, 132, 143, 40, 15, 127, 74, 213, 46, 47, 206, 141, 20, 66, 201, 215, 160}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/fixtures.cu b/crates/aiur/cuda/generated/fixtures.cu new file mode 100644 index 000000000..222333384 --- /dev/null +++ b/crates/aiur/cuda/generated/fixtures.cu @@ -0,0 +1,3108 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_fixtures { +using namespace aiur_trace; + +template struct Seed_fixtures_0 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_0(Seed_fixtures_0 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_4 = goldilocks_mul(v_0, v_1); + row[layout.auxiliaries + 1] = v_4; + const uint64_t v_5 = 7ULL; + const uint64_t v_6 = goldilocks_mul(v_4, v_5); + const uint64_t v_7 = uint64_t(v_6 == 0); + row[layout.auxiliaries + 2] = inverse(v_6); + row[layout.auxiliaries + 3] = v_7; + const uint64_t v_8 = uint64_t(v_0 == 0); + row[layout.auxiliaries + 4] = inverse(v_0); + row[layout.auxiliaries + 5] = v_8; + const uint64_t v_9 = inverse(v_0); + row[layout.auxiliaries + 6] = v_9; + const uint64_t v_10 = ((v_0 >> 0) & 255ULL); + const uint64_t v_11 = ((v_0 >> 8) & 255ULL); + const uint64_t v_12 = ((v_0 >> 16) & 255ULL); + const uint64_t v_13 = ((v_0 >> 24) & 255ULL); + const uint64_t v_14 = ((v_0 >> 32) & 255ULL); + const uint64_t v_15 = ((v_0 >> 40) & 255ULL); + const uint64_t v_16 = ((v_0 >> 48) & 255ULL); + const uint64_t v_17 = ((v_0 >> 56) & 255ULL); + row[layout.auxiliaries + 7] = v_10; + row[layout.auxiliaries + 8] = v_11; + row[layout.auxiliaries + 9] = v_12; + row[layout.auxiliaries + 10] = v_13; + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.auxiliaries + 14] = v_17; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_0(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_0 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_0(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_0(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_0<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_0<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_0(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_0); +} + +template struct Seed_fixtures_1 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_1(Seed_fixtures_1 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = ((v_0 >> 0) & 1ULL); + const uint64_t v_3 = ((v_0 >> 1) & 1ULL); + const uint64_t v_4 = ((v_0 >> 2) & 1ULL); + const uint64_t v_5 = ((v_0 >> 3) & 1ULL); + const uint64_t v_6 = ((v_0 >> 4) & 1ULL); + const uint64_t v_7 = ((v_0 >> 5) & 1ULL); + const uint64_t v_8 = ((v_0 >> 6) & 1ULL); + const uint64_t v_9 = ((v_0 >> 7) & 1ULL); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + const uint64_t v_10 = ((v_0 << 1) & 255ULL); + row[layout.auxiliaries + 9] = v_10; + const uint64_t v_11 = (v_0 >> 1); + row[layout.auxiliaries + 10] = v_11; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_12 = (v_0 ^ v_1); + row[layout.auxiliaries + 11] = v_12; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_13 = ((v_0 + v_1) & 255ULL); + const uint64_t v_14 = ((v_0 + v_1) >> 8); + row[layout.auxiliaries + 12] = v_13; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_15 = ((v_0 - v_1) & 255ULL); + const uint64_t v_16 = uint64_t(v_0 < v_1); + row[layout.auxiliaries + 13] = v_15; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_17 = ((v_0 * v_1) & 255ULL); + const uint64_t v_18 = ((v_0 * v_1) >> 8); + row[layout.auxiliaries + 14] = v_17; + row[layout.auxiliaries + 15] = v_18; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_19 = (v_0 & v_1); + row[layout.auxiliaries + 16] = v_19; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_20 = (v_0 | v_1); + row[layout.auxiliaries + 17] = v_20; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_21 = uint64_t(v_0 < v_1); + row[layout.auxiliaries + 18] = v_21; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_22 = ((v_0 ^ v_1) >> 7); + const uint64_t v_23 = (((v_0 ^ v_1) << 1) & 255ULL); + row[layout.auxiliaries + 19] = v_22; + row[layout.auxiliaries + 20] = v_23; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_24 = ((v_0 ^ v_1) >> 4); + const uint64_t v_25 = (((v_0 ^ v_1) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_24; + row[layout.auxiliaries + 22] = v_25; + const uint64_t v_26 = goldilocks_mul(v_14, v_16); + row[layout.auxiliaries + 23] = v_26; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_1(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 24; + const Seed_fixtures_1 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_1(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_1(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_1<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_1<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_1(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 24) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_1); +} + +template struct Seed_fixtures_2 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_2(Seed_fixtures_2 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = canonicalize(word(v_0, v_1, v_2, v_3)); + const uint64_t v_13 = canonicalize(word(v_4, v_5, v_6, v_7)); + if (v_12 > 0xffffffffULL || v_13 > 0xffffffffULL) return 3; + const uint32_t op_2 = uint32_t(v_12) - uint32_t(v_13); + const uint64_t v_14 = uint64_t(v_12 < v_13); + row[layout.auxiliaries + 1] = (v_12 & 0xffffULL); + row[layout.auxiliaries + 2] = ((v_12 >> 16) & 0xffffULL); + row[layout.auxiliaries + 3] = (uint64_t(op_2) & 0xffffULL); + row[layout.auxiliaries + 4] = ((uint64_t(op_2) >> 16) & 0xffffULL); + row[layout.auxiliaries + 5] = (v_13 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_13 >> 16) & 0xffffULL); + const WordSum op_3 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7)); + const uint64_t v_15 = ((op_3.low >> 0) & 255ULL); + const uint64_t v_16 = ((op_3.low >> 8) & 255ULL); + const uint64_t v_17 = ((op_3.low >> 16) & 255ULL); + const uint64_t v_18 = ((op_3.low >> 24) & 255ULL); + const uint64_t v_19 = op_3.carry; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + const WordSum op_4 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7), word(v_8, v_9, v_10, v_11)); + const uint64_t v_20 = ((op_4.low >> 0) & 255ULL); + const uint64_t v_21 = ((op_4.low >> 8) & 255ULL); + const uint64_t v_22 = ((op_4.low >> 16) & 255ULL); + const uint64_t v_23 = ((op_4.low >> 24) & 255ULL); + const uint64_t v_24 = op_4.carry; + row[layout.auxiliaries + 11] = v_20; + row[layout.auxiliaries + 12] = v_21; + row[layout.auxiliaries + 13] = v_22; + row[layout.auxiliaries + 14] = v_23; + const uint64_t v_25 = goldilocks_mul(v_19, v_24); + row[layout.auxiliaries + 15] = v_25; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_2(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 104; + const Seed_fixtures_2 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_2(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_2(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_2<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_2<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_2(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 12 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_2); +} + +__device__ __constant__ uint64_t inverse_3_1[] = {0ULL, 1ULL}; +__device__ __constant__ uint64_t inverse_3_2[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_fixtures_3 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_3(Seed_fixtures_3 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + uint64_t v_6; + switch (v_0) { + case 0ULL: { + const uint64_t v_2 = goldilocks_mul(v_1, v_1); + row[layout.auxiliaries + 1] = v_2; + row[layout.selectors + 0] = 1; + v_6 = v_2; + goto continuation_0; + } + case 1ULL: { + if (v_1 > 255 || v_1 > 255) return 1; + const uint64_t v_3 = ((v_1 + v_1) & 255ULL); + const uint64_t v_4 = ((v_1 + v_1) >> 8); + row[layout.auxiliaries + 1] = v_3; + row[layout.selectors + 1] = 1; + v_6 = v_3; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_3_1[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + row[layout.auxiliaries + 2] = (v_0 <= 1ULL ? inverse_3_2[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); + const uint64_t v_5 = uint64_t(v_1 == 0); + row[layout.auxiliaries + 3] = inverse(v_1); + row[layout.auxiliaries + 4] = v_5; + row[layout.selectors + 2] = 1; + v_6 = v_5; + goto continuation_0; + } + } + continuation_0:; + row[layout.auxiliaries + 5] = v_6; + const uint64_t v_7 = goldilocks_mul(v_6, v_1); + row[layout.auxiliaries + 6] = v_7; + row[layout.selectors + 3] = 1; + return 0; +} +template __global__ void kernel_fixtures_3(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_3 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_3(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_3(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_3<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_3<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_3(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_3); +} + +template struct Seed_fixtures_4 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 32); + case 3: return load_u32(data + 36); + case 4: return load_u64(data + 16); + case 5: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_4(Seed_fixtures_4 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 2] = v_2; + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 3] = v_3; + const uint64_t v_4 = seed.word(4); + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_4(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 48; + const Seed_fixtures_4 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_4(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_4(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_4<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_4<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_4(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_4); +} + +template struct Seed_fixtures_5 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_5(Seed_fixtures_5 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_5(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 16; + const Seed_fixtures_5 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_5(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_5(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_5<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_5<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_5(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 16 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_5); +} + +template struct Seed_fixtures_6 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_6(Seed_fixtures_6 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 2] = v_2; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_6(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_6 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_6(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_6(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_6<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_6<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_6(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_6); +} + +template struct Seed_fixtures_7 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 40); + case 4: return load_u32(data + 44); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_7(Seed_fixtures_7 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_7(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 56; + const Seed_fixtures_7 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_7(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_7(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_7<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_7<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_7(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_7); +} + +__device__ __constant__ uint64_t inverse_8_1[] = {0ULL}; +template struct Seed_fixtures_8 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_8(Seed_fixtures_8 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_1 <= 0ULL ? inverse_8_1[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + row[layout.selectors + 1] = 1; + goto continuation_0; + } + } + continuation_0:; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 3] = v_2; + row[layout.selectors + 2] = 1; + return 0; +} +template __global__ void kernel_fixtures_8(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_8 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_8(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_8(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_8<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_8<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_8(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_8); +} + +__device__ __constant__ uint64_t inverse_9_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_9_2[] = {0ULL}; +template struct Seed_fixtures_9 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_9(Seed_fixtures_9 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + switch (v_0) { + case 0ULL: { + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_1 <= 0ULL ? inverse_9_1[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + row[layout.selectors + 1] = 1; + goto continuation_0; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 0ULL ? inverse_9_2[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + row[layout.selectors + 2] = 1; + goto continuation_0; + } + } + continuation_0:; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 3] = v_2; + row[layout.selectors + 3] = 1; + return 0; +} +template __global__ void kernel_fixtures_9(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_9 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_9(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_9(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_9<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_9<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_9(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_9); +} + +__device__ __constant__ uint64_t inverse_10_1[] = {0ULL}; +template struct Seed_fixtures_10 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u32(data + 40); + case 5: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_10(Seed_fixtures_10 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + uint64_t v_6; + switch (v_0) { + case 0ULL: { + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 1] = v_3; + row[layout.selectors + 0] = 1; + v_6 = v_3; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 0ULL ? inverse_10_1[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + const uint64_t v_4 = seed.word(3); + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.selectors + 1] = 1; + v_6 = v_5; + goto continuation_0; + } + } + continuation_0:; + row[layout.auxiliaries + 4] = v_6; + const uint64_t v_7 = seed.word(5); + row[layout.auxiliaries + 5] = v_7; + row[layout.selectors + 2] = 1; + return 0; +} +template __global__ void kernel_fixtures_10(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 48; + const Seed_fixtures_10 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_10(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_10(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_10<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_10<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_10(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_10); +} + +template struct Seed_fixtures_11 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 104); + case 4: return load_u32(data + 108); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + case 7: return load_u64(data + 40); + case 8: return load_u64(data + 48); + case 9: return load_u64(data + 56); + case 10: return load_u64(data + 64); + case 11: return load_u64(data + 72); + case 12: return load_u64(data + 80); + case 13: return load_u64(data + 88); + case 14: return load_u64(data + 96); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_11(Seed_fixtures_11 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_11(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 112 : 120; + const Seed_fixtures_11 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_11(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_11(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_11<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_11<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_11(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 13) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 120 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_11); +} + +template struct Seed_fixtures_12 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_12(Seed_fixtures_12 seed, Layout layout, uint64_t* row) { + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_12(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 8 : 8; + const Seed_fixtures_12 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_12(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_12(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_12<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_12<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_12(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 0 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 8 : encoding == 0 ? 8 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_12); +} + +template struct Seed_fixtures_14 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_14(Seed_fixtures_14 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_14(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_14 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_14(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_14(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_14<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_14<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_14(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 2) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_14); +} + +template struct Seed_fixtures_15 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_15(Seed_fixtures_15 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_15(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 16; + const Seed_fixtures_15 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_15(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_15(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_15<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_15<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_15(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 2) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 16 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_15); +} + +template struct Seed_fixtures_16 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_16(Seed_fixtures_16 seed, Layout layout, uint64_t* row) { + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_16(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 8 : 8; + const Seed_fixtures_16 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_16(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_16(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_16<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_16<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_16(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 0 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 8 : encoding == 0 ? 8 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_16); +} + +__device__ __constant__ uint64_t inverse_17_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_fixtures_17 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_17(Seed_fixtures_17 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_17_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_fixtures_17(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_fixtures_17 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_17(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_17(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_17<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_17<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_17(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_17); +} + +__device__ __constant__ uint64_t inverse_18_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_18_3[] = {0ULL}; +template struct Seed_fixtures_18 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_18(Seed_fixtures_18 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + uint64_t v_8; + switch (v_0) { + case 0ULL: { + uint64_t v_5; + switch (v_2) { + case 0ULL: { + const uint64_t v_3 = 0ULL; + row[layout.selectors + 0] = 1; + v_5 = v_3; + goto continuation_1; + } + default: { + row[layout.auxiliaries + 1] = (v_2 <= 0ULL ? inverse_18_2[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_4 = 1ULL; + row[layout.selectors + 1] = 1; + v_5 = v_4; + goto continuation_1; + } + } + continuation_1:; + row[layout.auxiliaries + 2] = v_5; + const uint64_t v_6 = goldilocks_add(v_5, v_2); + row[layout.selectors + 2] = 1; + v_8 = v_6; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 0ULL ? inverse_18_3[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + const uint64_t v_7 = 2ULL; + row[layout.selectors + 3] = 1; + v_8 = v_7; + goto continuation_0; + } + } + continuation_0:; + row[layout.auxiliaries + 3] = v_8; + const uint64_t v_9 = seed.word(4); + row[layout.auxiliaries + 4] = v_9; + row[layout.selectors + 4] = 1; + return 0; +} +template __global__ void kernel_fixtures_18(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 40; + const Seed_fixtures_18 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_18(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_18(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_18<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_18<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_18(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_18); +} + +template struct Seed_fixtures_19 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_19(Seed_fixtures_19 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + switch (v_0) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_fixtures_19(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 16; + const Seed_fixtures_19 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_19(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_19(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_19<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_19<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_19(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 16 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_19); +} + +template struct Seed_fixtures_20 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_20(Seed_fixtures_20 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const WordSum op_0 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7)); + const uint64_t v_12 = ((op_0.low >> 0) & 255ULL); + const uint64_t v_13 = ((op_0.low >> 8) & 255ULL); + const uint64_t v_14 = ((op_0.low >> 16) & 255ULL); + const uint64_t v_15 = ((op_0.low >> 24) & 255ULL); + const uint64_t v_16 = op_0.carry; + row[layout.auxiliaries + 1] = v_12; + row[layout.auxiliaries + 2] = v_13; + row[layout.auxiliaries + 3] = v_14; + row[layout.auxiliaries + 4] = v_15; + const WordSum op_1 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7), word(v_8, v_9, v_10, v_11)); + const uint64_t v_17 = ((op_1.low >> 0) & 255ULL); + const uint64_t v_18 = ((op_1.low >> 8) & 255ULL); + const uint64_t v_19 = ((op_1.low >> 16) & 255ULL); + const uint64_t v_20 = ((op_1.low >> 24) & 255ULL); + const uint64_t v_21 = op_1.carry; + row[layout.auxiliaries + 5] = v_17; + row[layout.auxiliaries + 6] = v_18; + row[layout.auxiliaries + 7] = v_19; + row[layout.auxiliaries + 8] = v_20; + const uint64_t v_22 = goldilocks_mul(v_16, v_21); + row[layout.auxiliaries + 9] = v_22; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_20(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 104; + const Seed_fixtures_20 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_20(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_20(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_20<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_20<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_20(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 12 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 10) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_20); +} + +template struct Seed_fixtures_21 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u64(data + 48); + case 7: return load_u64(data + 56); + case 8: return load_u64(data + 64); + case 9: return load_u64(data + 72); + case 10: return load_u64(data + 80); + case 11: return load_u64(data + 88); + case 12: return load_u64(data + 96); + case 13: return load_u64(data + 104); + case 14: return load_u64(data + 112); + case 15: return load_u64(data + 120); + case 16: return load_u64(data + 128); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_21(Seed_fixtures_21 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = 256ULL; + const uint64_t v_17 = goldilocks_mul(v_16, v_1); + const uint64_t v_18 = goldilocks_add(v_0, v_17); + const uint64_t v_19 = goldilocks_mul(v_16, v_9); + const uint64_t v_20 = goldilocks_add(v_8, v_19); + const uint64_t v_21 = goldilocks_mul(v_16, v_3); + const uint64_t v_22 = goldilocks_add(v_2, v_21); + const uint64_t v_23 = goldilocks_mul(v_16, v_11); + const uint64_t v_24 = goldilocks_add(v_10, v_23); + const uint64_t v_25 = goldilocks_mul(v_16, v_5); + const uint64_t v_26 = goldilocks_add(v_4, v_25); + const uint64_t v_27 = goldilocks_mul(v_16, v_13); + const uint64_t v_28 = goldilocks_add(v_12, v_27); + const uint64_t v_29 = goldilocks_mul(v_16, v_7); + const uint64_t v_30 = goldilocks_add(v_6, v_29); + const uint64_t v_31 = goldilocks_mul(v_16, v_15); + const uint64_t v_32 = goldilocks_add(v_14, v_31); + const uint64_t v_33 = goldilocks_mul(v_18, v_20); + row[layout.auxiliaries + 1] = v_33; + const uint64_t v_34 = ((v_33 >> 0) & 255ULL); + const uint64_t v_35 = ((v_33 >> 8) & 255ULL); + const uint64_t v_36 = ((v_33 >> 16) & 255ULL); + const uint64_t v_37 = ((v_33 >> 24) & 255ULL); + const uint64_t v_38 = ((v_33 >> 32) & 255ULL); + const uint64_t v_39 = ((v_33 >> 40) & 255ULL); + const uint64_t v_40 = ((v_33 >> 48) & 255ULL); + const uint64_t v_41 = ((v_33 >> 56) & 255ULL); + row[layout.auxiliaries + 2] = v_34; + row[layout.auxiliaries + 3] = v_35; + row[layout.auxiliaries + 4] = v_36; + row[layout.auxiliaries + 5] = v_37; + row[layout.auxiliaries + 6] = v_38; + row[layout.auxiliaries + 7] = v_39; + row[layout.auxiliaries + 8] = v_40; + row[layout.auxiliaries + 9] = v_41; + const uint64_t v_44 = 65536ULL; + const uint64_t v_45 = goldilocks_mul(v_16, v_37); + const uint64_t v_46 = goldilocks_mul(v_44, v_38); + const uint64_t v_47 = goldilocks_add(v_45, v_46); + const uint64_t v_48 = goldilocks_add(v_36, v_47); + const uint64_t v_52 = goldilocks_mul(v_18, v_24); + row[layout.auxiliaries + 10] = v_52; + const uint64_t v_53 = goldilocks_mul(v_22, v_20); + row[layout.auxiliaries + 11] = v_53; + const uint64_t v_54 = goldilocks_add(v_53, v_48); + const uint64_t v_55 = goldilocks_add(v_52, v_54); + const uint64_t v_56 = ((v_55 >> 0) & 255ULL); + const uint64_t v_57 = ((v_55 >> 8) & 255ULL); + const uint64_t v_58 = ((v_55 >> 16) & 255ULL); + const uint64_t v_59 = ((v_55 >> 24) & 255ULL); + const uint64_t v_60 = ((v_55 >> 32) & 255ULL); + const uint64_t v_61 = ((v_55 >> 40) & 255ULL); + const uint64_t v_62 = ((v_55 >> 48) & 255ULL); + const uint64_t v_63 = ((v_55 >> 56) & 255ULL); + row[layout.auxiliaries + 12] = v_56; + row[layout.auxiliaries + 13] = v_57; + row[layout.auxiliaries + 14] = v_58; + row[layout.auxiliaries + 15] = v_59; + row[layout.auxiliaries + 16] = v_60; + row[layout.auxiliaries + 17] = v_61; + row[layout.auxiliaries + 18] = v_62; + row[layout.auxiliaries + 19] = v_63; + const uint64_t v_65 = goldilocks_mul(v_16, v_59); + const uint64_t v_66 = goldilocks_mul(v_44, v_60); + const uint64_t v_67 = goldilocks_add(v_65, v_66); + const uint64_t v_68 = goldilocks_add(v_58, v_67); + const uint64_t v_72 = goldilocks_mul(v_18, v_28); + row[layout.auxiliaries + 20] = v_72; + const uint64_t v_73 = goldilocks_mul(v_22, v_24); + row[layout.auxiliaries + 21] = v_73; + const uint64_t v_74 = goldilocks_mul(v_26, v_20); + row[layout.auxiliaries + 22] = v_74; + const uint64_t v_75 = goldilocks_add(v_74, v_68); + const uint64_t v_76 = goldilocks_add(v_73, v_75); + const uint64_t v_77 = goldilocks_add(v_72, v_76); + const uint64_t v_78 = ((v_77 >> 0) & 255ULL); + const uint64_t v_79 = ((v_77 >> 8) & 255ULL); + const uint64_t v_80 = ((v_77 >> 16) & 255ULL); + const uint64_t v_81 = ((v_77 >> 24) & 255ULL); + const uint64_t v_82 = ((v_77 >> 32) & 255ULL); + const uint64_t v_83 = ((v_77 >> 40) & 255ULL); + const uint64_t v_84 = ((v_77 >> 48) & 255ULL); + const uint64_t v_85 = ((v_77 >> 56) & 255ULL); + row[layout.auxiliaries + 23] = v_78; + row[layout.auxiliaries + 24] = v_79; + row[layout.auxiliaries + 25] = v_80; + row[layout.auxiliaries + 26] = v_81; + row[layout.auxiliaries + 27] = v_82; + row[layout.auxiliaries + 28] = v_83; + row[layout.auxiliaries + 29] = v_84; + row[layout.auxiliaries + 30] = v_85; + const uint64_t v_87 = goldilocks_mul(v_16, v_81); + const uint64_t v_88 = goldilocks_mul(v_44, v_82); + const uint64_t v_89 = goldilocks_add(v_87, v_88); + const uint64_t v_90 = goldilocks_add(v_80, v_89); + const uint64_t v_94 = goldilocks_mul(v_18, v_32); + row[layout.auxiliaries + 31] = v_94; + const uint64_t v_95 = goldilocks_mul(v_22, v_28); + row[layout.auxiliaries + 32] = v_95; + const uint64_t v_96 = goldilocks_mul(v_26, v_24); + row[layout.auxiliaries + 33] = v_96; + const uint64_t v_97 = goldilocks_mul(v_30, v_20); + row[layout.auxiliaries + 34] = v_97; + const uint64_t v_98 = goldilocks_add(v_97, v_90); + const uint64_t v_99 = goldilocks_add(v_96, v_98); + const uint64_t v_100 = goldilocks_add(v_95, v_99); + const uint64_t v_101 = goldilocks_add(v_94, v_100); + const uint64_t v_102 = ((v_101 >> 0) & 255ULL); + const uint64_t v_103 = ((v_101 >> 8) & 255ULL); + const uint64_t v_104 = ((v_101 >> 16) & 255ULL); + const uint64_t v_105 = ((v_101 >> 24) & 255ULL); + const uint64_t v_106 = ((v_101 >> 32) & 255ULL); + const uint64_t v_107 = ((v_101 >> 40) & 255ULL); + const uint64_t v_108 = ((v_101 >> 48) & 255ULL); + const uint64_t v_109 = ((v_101 >> 56) & 255ULL); + row[layout.auxiliaries + 35] = v_102; + row[layout.auxiliaries + 36] = v_103; + row[layout.auxiliaries + 37] = v_104; + row[layout.auxiliaries + 38] = v_105; + row[layout.auxiliaries + 39] = v_106; + row[layout.auxiliaries + 40] = v_107; + row[layout.auxiliaries + 41] = v_108; + row[layout.auxiliaries + 42] = v_109; + const uint64_t v_111 = goldilocks_mul(v_16, v_105); + const uint64_t v_112 = goldilocks_mul(v_44, v_106); + const uint64_t v_113 = goldilocks_add(v_111, v_112); + const uint64_t v_114 = goldilocks_add(v_104, v_113); + const uint64_t v_118 = goldilocks_mul(v_22, v_32); + row[layout.auxiliaries + 43] = v_118; + const uint64_t v_119 = goldilocks_mul(v_26, v_28); + row[layout.auxiliaries + 44] = v_119; + const uint64_t v_120 = goldilocks_mul(v_30, v_24); + row[layout.auxiliaries + 45] = v_120; + const uint64_t v_121 = goldilocks_add(v_120, v_114); + const uint64_t v_122 = goldilocks_add(v_119, v_121); + const uint64_t v_123 = goldilocks_add(v_118, v_122); + const uint64_t v_124 = ((v_123 >> 0) & 255ULL); + const uint64_t v_125 = ((v_123 >> 8) & 255ULL); + const uint64_t v_126 = ((v_123 >> 16) & 255ULL); + const uint64_t v_127 = ((v_123 >> 24) & 255ULL); + const uint64_t v_128 = ((v_123 >> 32) & 255ULL); + const uint64_t v_129 = ((v_123 >> 40) & 255ULL); + const uint64_t v_130 = ((v_123 >> 48) & 255ULL); + const uint64_t v_131 = ((v_123 >> 56) & 255ULL); + row[layout.auxiliaries + 46] = v_124; + row[layout.auxiliaries + 47] = v_125; + row[layout.auxiliaries + 48] = v_126; + row[layout.auxiliaries + 49] = v_127; + row[layout.auxiliaries + 50] = v_128; + row[layout.auxiliaries + 51] = v_129; + row[layout.auxiliaries + 52] = v_130; + row[layout.auxiliaries + 53] = v_131; + const uint64_t v_133 = goldilocks_mul(v_16, v_127); + const uint64_t v_134 = goldilocks_mul(v_44, v_128); + const uint64_t v_135 = goldilocks_add(v_133, v_134); + const uint64_t v_136 = goldilocks_add(v_126, v_135); + const uint64_t v_140 = goldilocks_mul(v_26, v_32); + row[layout.auxiliaries + 54] = v_140; + const uint64_t v_141 = goldilocks_mul(v_30, v_28); + row[layout.auxiliaries + 55] = v_141; + const uint64_t v_142 = goldilocks_add(v_141, v_136); + const uint64_t v_143 = goldilocks_add(v_140, v_142); + const uint64_t v_144 = ((v_143 >> 0) & 255ULL); + const uint64_t v_145 = ((v_143 >> 8) & 255ULL); + const uint64_t v_146 = ((v_143 >> 16) & 255ULL); + const uint64_t v_147 = ((v_143 >> 24) & 255ULL); + const uint64_t v_148 = ((v_143 >> 32) & 255ULL); + const uint64_t v_149 = ((v_143 >> 40) & 255ULL); + const uint64_t v_150 = ((v_143 >> 48) & 255ULL); + const uint64_t v_151 = ((v_143 >> 56) & 255ULL); + row[layout.auxiliaries + 56] = v_144; + row[layout.auxiliaries + 57] = v_145; + row[layout.auxiliaries + 58] = v_146; + row[layout.auxiliaries + 59] = v_147; + row[layout.auxiliaries + 60] = v_148; + row[layout.auxiliaries + 61] = v_149; + row[layout.auxiliaries + 62] = v_150; + row[layout.auxiliaries + 63] = v_151; + const uint64_t v_153 = goldilocks_mul(v_16, v_147); + const uint64_t v_154 = goldilocks_mul(v_44, v_148); + const uint64_t v_155 = goldilocks_add(v_153, v_154); + const uint64_t v_156 = goldilocks_add(v_146, v_155); + const uint64_t v_160 = goldilocks_mul(v_30, v_32); + row[layout.auxiliaries + 64] = v_160; + const uint64_t v_161 = goldilocks_add(v_160, v_156); + const uint64_t v_162 = ((v_161 >> 0) & 255ULL); + const uint64_t v_163 = ((v_161 >> 8) & 255ULL); + const uint64_t v_164 = ((v_161 >> 16) & 255ULL); + const uint64_t v_165 = ((v_161 >> 24) & 255ULL); + const uint64_t v_166 = ((v_161 >> 32) & 255ULL); + const uint64_t v_167 = ((v_161 >> 40) & 255ULL); + const uint64_t v_168 = ((v_161 >> 48) & 255ULL); + const uint64_t v_169 = ((v_161 >> 56) & 255ULL); + row[layout.auxiliaries + 65] = v_162; + row[layout.auxiliaries + 66] = v_163; + row[layout.auxiliaries + 67] = v_164; + row[layout.auxiliaries + 68] = v_165; + row[layout.auxiliaries + 69] = v_166; + row[layout.auxiliaries + 70] = v_167; + row[layout.auxiliaries + 71] = v_168; + row[layout.auxiliaries + 72] = v_169; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_21(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 136 : 136; + const Seed_fixtures_21 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_21(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_21(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_21<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_21<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_21(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 73) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 136 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_21); +} + +extern "C" const uint8_t* aiur_trace_fixtures_contract() { + static const uint8_t hash[32] = {213, 235, 108, 220, 115, 159, 51, 229, 206, 4, 193, 234, 222, 143, 95, 162, 130, 93, 210, 36, 144, 208, 151, 97, 95, 24, 25, 23, 225, 30, 236, 67}; + return hash; +} +extern "C" const uint8_t* aiur_trace_fixtures_schema() { + static const uint8_t hash[32] = {37, 185, 21, 81, 113, 228, 73, 167, 217, 138, 89, 160, 206, 9, 127, 220, 167, 73, 73, 205, 226, 204, 26, 55, 228, 3, 11, 111, 3, 154, 149, 82}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/ix_aggr.cu b/crates/aiur/cuda/generated/production/ix_aggr.cu new file mode 100644 index 000000000..adc95f6fe --- /dev/null +++ b/crates/aiur/cuda/generated/production/ix_aggr.cu @@ -0,0 +1,2801 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_ix_aggr { +using namespace aiur_trace; + +__device__ __constant__ uint64_t inverse_86_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ix_aggr_86 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_86(Seed_ix_aggr_86 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_86_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ix_aggr_86(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_ix_aggr_86 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_86(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_86(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_86<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_86<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_86(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_86); +} + +__device__ __constant__ uint64_t inverse_117_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_3[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_4[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_5[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_6[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_7[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_8[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_10[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_117_11[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_117_12[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_117_13[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ix_aggr_117 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 312); + case 2: return load_u32(data + 316); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 320); + case 5: return load_u32(data + 324); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 404); + case 8: return load_u8(data + 405); + case 9: return load_u8(data + 406); + case 10: return load_u8(data + 407); + case 11: return load_u8(data + 408); + case 12: return load_u8(data + 409); + case 13: return load_u8(data + 410); + case 14: return load_u8(data + 411); + case 15: return load_u32(data + 328); + case 16: return load_u32(data + 332); + case 17: return load_u8(data + 412); + case 18: return load_u64(data + 24); + case 19: return load_u64(data + 32); + case 20: return load_u64(data + 40); + case 21: return load_u64(data + 48); + case 22: return load_u64(data + 56); + case 23: return load_u64(data + 64); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u32(data + 336); + case 27: return load_u32(data + 340); + case 28: return load_u8(data + 413); + case 29: return load_u8(data + 414); + case 30: return load_u8(data + 415); + case 31: return load_u8(data + 416); + case 32: return load_u8(data + 417); + case 33: return load_u8(data + 418); + case 34: return load_u8(data + 419); + case 35: return load_u8(data + 420); + case 36: return load_u8(data + 421); + case 37: return load_u32(data + 344); + case 38: return load_u32(data + 348); + case 39: return load_u8(data + 422); + case 40: return load_u8(data + 423); + case 41: return load_u8(data + 424); + case 42: return load_u8(data + 425); + case 43: return load_u8(data + 426); + case 44: return load_u8(data + 427); + case 45: return load_u8(data + 428); + case 46: return load_u8(data + 429); + case 47: return load_u8(data + 430); + case 48: return load_u32(data + 352); + case 49: return load_u32(data + 356); + case 50: return load_u8(data + 431); + case 51: return load_u8(data + 432); + case 52: return load_u8(data + 433); + case 53: return load_u8(data + 434); + case 54: return load_u8(data + 435); + case 55: return load_u8(data + 436); + case 56: return load_u8(data + 437); + case 57: return load_u8(data + 438); + case 58: return load_u8(data + 439); + case 59: return load_u32(data + 360); + case 60: return load_u32(data + 364); + case 61: return load_u8(data + 440); + case 62: return load_u8(data + 441); + case 63: return load_u8(data + 442); + case 64: return load_u8(data + 443); + case 65: return load_u8(data + 444); + case 66: return load_u8(data + 445); + case 67: return load_u8(data + 446); + case 68: return load_u8(data + 447); + case 69: return load_u8(data + 448); + case 70: return load_u32(data + 368); + case 71: return load_u32(data + 372); + case 72: return load_u8(data + 449); + case 73: return load_u8(data + 450); + case 74: return load_u8(data + 451); + case 75: return load_u8(data + 452); + case 76: return load_u8(data + 453); + case 77: return load_u8(data + 454); + case 78: return load_u8(data + 455); + case 79: return load_u8(data + 456); + case 80: return load_u8(data + 457); + case 81: return load_u32(data + 376); + case 82: return load_u32(data + 380); + case 83: return load_u8(data + 458); + case 84: return load_u8(data + 459); + case 85: return load_u8(data + 460); + case 86: return load_u8(data + 461); + case 87: return load_u8(data + 462); + case 88: return load_u8(data + 463); + case 89: return load_u8(data + 464); + case 90: return load_u8(data + 465); + case 91: return load_u8(data + 466); + case 92: return load_u32(data + 384); + case 93: return load_u32(data + 388); + case 94: return load_u8(data + 467); + case 95: return load_u8(data + 468); + case 96: return load_u64(data + 88); + case 97: return load_u64(data + 96); + case 98: return load_u64(data + 104); + case 99: return load_u64(data + 112); + case 100: return load_u64(data + 120); + case 101: return load_u64(data + 128); + case 102: return load_u64(data + 136); + case 103: return load_u64(data + 144); + case 104: return load_u64(data + 152); + case 105: return load_u8(data + 469); + case 106: return load_u64(data + 160); + case 107: return load_u64(data + 168); + case 108: return load_u8(data + 470); + case 109: return load_u8(data + 471); + case 110: return load_u8(data + 472); + case 111: return load_u8(data + 473); + case 112: return load_u8(data + 474); + case 113: return load_u8(data + 475); + case 114: return load_u8(data + 476); + case 115: return load_u8(data + 477); + case 116: return load_u8(data + 478); + case 117: return load_u8(data + 479); + case 118: return load_u8(data + 480); + case 119: return load_u8(data + 481); + case 120: return load_u8(data + 482); + case 121: return load_u8(data + 483); + case 122: return load_u8(data + 484); + case 123: return load_u8(data + 485); + case 124: return load_u8(data + 486); + case 125: return load_u8(data + 487); + case 126: return load_u8(data + 488); + case 127: return load_u8(data + 489); + case 128: return load_u8(data + 490); + case 129: return load_u8(data + 491); + case 130: return load_u8(data + 492); + case 131: return load_u8(data + 493); + case 132: return load_u8(data + 494); + case 133: return load_u8(data + 495); + case 134: return load_u8(data + 496); + case 135: return load_u8(data + 497); + case 136: return load_u8(data + 498); + case 137: return load_u8(data + 499); + case 138: return load_u8(data + 500); + case 139: return load_u8(data + 501); + case 140: return load_u8(data + 502); + case 141: return load_u8(data + 503); + case 142: return load_u8(data + 504); + case 143: return load_u8(data + 505); + case 144: return load_u8(data + 506); + case 145: return load_u8(data + 507); + case 146: return load_u8(data + 508); + case 147: return load_u8(data + 509); + case 148: return load_u8(data + 510); + case 149: return load_u8(data + 511); + case 150: return load_u8(data + 512); + case 151: return load_u8(data + 513); + case 152: return load_u8(data + 514); + case 153: return load_u8(data + 515); + case 154: return load_u8(data + 516); + case 155: return load_u8(data + 517); + case 156: return load_u8(data + 518); + case 157: return load_u8(data + 519); + case 158: return load_u8(data + 520); + case 159: return load_u8(data + 521); + case 160: return load_u8(data + 522); + case 161: return load_u8(data + 523); + case 162: return load_u8(data + 524); + case 163: return load_u8(data + 525); + case 164: return load_u8(data + 526); + case 165: return load_u8(data + 527); + case 166: return load_u8(data + 528); + case 167: return load_u8(data + 529); + case 168: return load_u8(data + 530); + case 169: return load_u8(data + 531); + case 170: return load_u8(data + 532); + case 171: return load_u8(data + 533); + case 172: return load_u8(data + 534); + case 173: return load_u8(data + 535); + case 174: return load_u8(data + 536); + case 175: return load_u8(data + 537); + case 176: return load_u8(data + 538); + case 177: return load_u8(data + 539); + case 178: return load_u8(data + 540); + case 179: return load_u8(data + 541); + case 180: return load_u8(data + 542); + case 181: return load_u64(data + 176); + case 182: return load_u64(data + 184); + case 183: return load_u64(data + 192); + case 184: return load_u64(data + 200); + case 185: return load_u64(data + 208); + case 186: return load_u64(data + 216); + case 187: return load_u64(data + 224); + case 188: return load_u64(data + 232); + case 189: return load_u64(data + 240); + case 190: return load_u64(data + 248); + case 191: return load_u64(data + 256); + case 192: return load_u64(data + 264); + case 193: return load_u64(data + 272); + case 194: return load_u64(data + 280); + case 195: return load_u64(data + 288); + case 196: return load_u64(data + 296); + case 197: return load_u32(data + 392); + case 198: return load_u32(data + 396); + case 199: return load_u32(data + 400); + case 200: return load_u64(data + 304); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_117(Seed_ix_aggr_117 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + row[layout.auxiliaries + 1] = v_6; + row[layout.auxiliaries + 2] = v_7; + row[layout.auxiliaries + 3] = v_8; + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.auxiliaries + 7] = v_12; + row[layout.auxiliaries + 8] = v_13; + row[layout.auxiliaries + 9] = v_14; + row[layout.auxiliaries + 10] = v_15; + row[layout.auxiliaries + 11] = v_16; + switch (v_16) { + case 0ULL: { + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 12] = v_17; + row[layout.auxiliaries + 13] = v_18; + row[layout.auxiliaries + 14] = v_19; + row[layout.auxiliaries + 15] = v_20; + row[layout.auxiliaries + 16] = v_21; + row[layout.auxiliaries + 17] = v_22; + row[layout.auxiliaries + 18] = v_23; + row[layout.auxiliaries + 19] = v_24; + switch (v_17) { + case 0ULL: { + switch (v_18) { + case 0ULL: { + switch (v_19) { + case 0ULL: { + switch (v_20) { + case 0ULL: { + switch (v_21) { + case 0ULL: { + switch (v_22) { + case 0ULL: { + switch (v_23) { + case 0ULL: { + switch (v_24) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + row[layout.auxiliaries + 20] = v_25; + row[layout.auxiliaries + 21] = v_26; + row[layout.auxiliaries + 22] = v_27; + row[layout.auxiliaries + 23] = v_28; + row[layout.auxiliaries + 24] = v_29; + row[layout.auxiliaries + 25] = v_30; + row[layout.auxiliaries + 26] = v_31; + row[layout.auxiliaries + 27] = v_32; + row[layout.auxiliaries + 28] = v_33; + row[layout.auxiliaries + 29] = v_34; + row[layout.auxiliaries + 30] = v_35; + row[layout.auxiliaries + 31] = v_36; + row[layout.auxiliaries + 32] = v_37; + row[layout.auxiliaries + 33] = v_38; + row[layout.auxiliaries + 34] = v_39; + row[layout.auxiliaries + 35] = v_40; + row[layout.auxiliaries + 36] = v_41; + row[layout.auxiliaries + 37] = v_42; + row[layout.auxiliaries + 38] = v_43; + row[layout.auxiliaries + 39] = v_44; + row[layout.auxiliaries + 40] = v_45; + row[layout.auxiliaries + 41] = v_46; + row[layout.auxiliaries + 42] = v_47; + row[layout.auxiliaries + 43] = v_48; + row[layout.auxiliaries + 44] = v_49; + row[layout.auxiliaries + 45] = v_50; + row[layout.auxiliaries + 46] = v_51; + row[layout.auxiliaries + 47] = v_52; + row[layout.auxiliaries + 48] = v_53; + row[layout.auxiliaries + 49] = v_54; + row[layout.auxiliaries + 50] = v_55; + row[layout.auxiliaries + 51] = v_56; + const uint64_t v_58 = seed.word(58); + const uint64_t v_59 = seed.word(59); + const uint64_t v_60 = seed.word(60); + const uint64_t v_61 = seed.word(61); + const uint64_t v_62 = seed.word(62); + const uint64_t v_63 = seed.word(63); + const uint64_t v_64 = seed.word(64); + const uint64_t v_65 = seed.word(65); + row[layout.auxiliaries + 52] = v_58; + row[layout.auxiliaries + 53] = v_59; + row[layout.auxiliaries + 54] = v_60; + row[layout.auxiliaries + 55] = v_61; + row[layout.auxiliaries + 56] = v_62; + row[layout.auxiliaries + 57] = v_63; + row[layout.auxiliaries + 58] = v_64; + row[layout.auxiliaries + 59] = v_65; + const uint64_t v_82 = seed.word(66); + const uint64_t v_83 = seed.word(67); + const uint64_t v_84 = seed.word(68); + const uint64_t v_85 = seed.word(69); + const uint64_t v_86 = seed.word(70); + const uint64_t v_87 = seed.word(71); + const uint64_t v_88 = seed.word(72); + const uint64_t v_89 = seed.word(73); + const uint64_t v_90 = seed.word(74); + const uint64_t v_91 = seed.word(75); + const uint64_t v_92 = seed.word(76); + const uint64_t v_93 = seed.word(77); + const uint64_t v_94 = seed.word(78); + const uint64_t v_95 = seed.word(79); + const uint64_t v_96 = seed.word(80); + const uint64_t v_97 = seed.word(81); + const uint64_t v_98 = seed.word(82); + const uint64_t v_99 = seed.word(83); + const uint64_t v_100 = seed.word(84); + const uint64_t v_101 = seed.word(85); + const uint64_t v_102 = seed.word(86); + const uint64_t v_103 = seed.word(87); + const uint64_t v_104 = seed.word(88); + const uint64_t v_105 = seed.word(89); + const uint64_t v_106 = seed.word(90); + const uint64_t v_107 = seed.word(91); + const uint64_t v_108 = seed.word(92); + const uint64_t v_109 = seed.word(93); + const uint64_t v_110 = seed.word(94); + const uint64_t v_111 = seed.word(95); + const uint64_t v_112 = seed.word(96); + const uint64_t v_113 = seed.word(97); + row[layout.auxiliaries + 60] = v_82; + row[layout.auxiliaries + 61] = v_83; + row[layout.auxiliaries + 62] = v_84; + row[layout.auxiliaries + 63] = v_85; + row[layout.auxiliaries + 64] = v_86; + row[layout.auxiliaries + 65] = v_87; + row[layout.auxiliaries + 66] = v_88; + row[layout.auxiliaries + 67] = v_89; + row[layout.auxiliaries + 68] = v_90; + row[layout.auxiliaries + 69] = v_91; + row[layout.auxiliaries + 70] = v_92; + row[layout.auxiliaries + 71] = v_93; + row[layout.auxiliaries + 72] = v_94; + row[layout.auxiliaries + 73] = v_95; + row[layout.auxiliaries + 74] = v_96; + row[layout.auxiliaries + 75] = v_97; + row[layout.auxiliaries + 76] = v_98; + row[layout.auxiliaries + 77] = v_99; + row[layout.auxiliaries + 78] = v_100; + row[layout.auxiliaries + 79] = v_101; + row[layout.auxiliaries + 80] = v_102; + row[layout.auxiliaries + 81] = v_103; + row[layout.auxiliaries + 82] = v_104; + row[layout.auxiliaries + 83] = v_105; + row[layout.auxiliaries + 84] = v_106; + row[layout.auxiliaries + 85] = v_107; + row[layout.auxiliaries + 86] = v_108; + row[layout.auxiliaries + 87] = v_109; + row[layout.auxiliaries + 88] = v_110; + row[layout.auxiliaries + 89] = v_111; + row[layout.auxiliaries + 90] = v_112; + row[layout.auxiliaries + 91] = v_113; + const uint64_t v_114 = seed.word(98); + row[layout.auxiliaries + 92] = v_114; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 20] = (v_24 <= 0ULL ? inverse_117_0[v_24] : inverse(goldilocks_sub(v_24, 0ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_23 <= 0ULL ? inverse_117_1[v_23] : inverse(goldilocks_sub(v_23, 0ULL))); + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_22 <= 0ULL ? inverse_117_2[v_22] : inverse(goldilocks_sub(v_22, 0ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_21 <= 0ULL ? inverse_117_3[v_21] : inverse(goldilocks_sub(v_21, 0ULL))); + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_20 <= 0ULL ? inverse_117_4[v_20] : inverse(goldilocks_sub(v_20, 0ULL))); + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_19 <= 0ULL ? inverse_117_5[v_19] : inverse(goldilocks_sub(v_19, 0ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_18 <= 0ULL ? inverse_117_6[v_18] : inverse(goldilocks_sub(v_18, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_17 <= 0ULL ? inverse_117_7[v_17] : inverse(goldilocks_sub(v_17, 0ULL))); + row[layout.selectors + 8] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 12] = (v_16 <= 0ULL ? inverse_117_8[v_16] : inverse(goldilocks_sub(v_16, 0ULL))); + const uint64_t v_115 = seed.word(18); + const uint64_t v_116 = seed.word(19); + const uint64_t v_117 = seed.word(20); + const uint64_t v_118 = seed.word(21); + const uint64_t v_119 = seed.word(22); + const uint64_t v_120 = seed.word(23); + const uint64_t v_121 = seed.word(24); + const uint64_t v_122 = seed.word(25); + const uint64_t v_123 = seed.word(26); + const uint64_t v_124 = seed.word(27); + const uint64_t v_125 = seed.word(28); + row[layout.auxiliaries + 13] = v_115; + row[layout.auxiliaries + 14] = v_116; + row[layout.auxiliaries + 15] = v_117; + row[layout.auxiliaries + 16] = v_118; + row[layout.auxiliaries + 17] = v_119; + row[layout.auxiliaries + 18] = v_120; + row[layout.auxiliaries + 19] = v_121; + row[layout.auxiliaries + 20] = v_122; + row[layout.auxiliaries + 21] = v_123; + row[layout.auxiliaries + 22] = v_124; + row[layout.auxiliaries + 23] = v_125; + const uint64_t v_126 = seed.word(29); + const uint64_t v_127 = seed.word(30); + const uint64_t v_128 = seed.word(31); + const uint64_t v_129 = seed.word(32); + const uint64_t v_130 = seed.word(33); + const uint64_t v_131 = seed.word(34); + const uint64_t v_132 = seed.word(35); + const uint64_t v_133 = seed.word(36); + const uint64_t v_134 = seed.word(37); + const uint64_t v_135 = seed.word(38); + const uint64_t v_136 = seed.word(39); + row[layout.auxiliaries + 24] = v_126; + row[layout.auxiliaries + 25] = v_127; + row[layout.auxiliaries + 26] = v_128; + row[layout.auxiliaries + 27] = v_129; + row[layout.auxiliaries + 28] = v_130; + row[layout.auxiliaries + 29] = v_131; + row[layout.auxiliaries + 30] = v_132; + row[layout.auxiliaries + 31] = v_133; + row[layout.auxiliaries + 32] = v_134; + row[layout.auxiliaries + 33] = v_135; + row[layout.auxiliaries + 34] = v_136; + const uint64_t v_137 = seed.word(40); + const uint64_t v_138 = seed.word(41); + const uint64_t v_139 = seed.word(42); + const uint64_t v_140 = seed.word(43); + const uint64_t v_141 = seed.word(44); + const uint64_t v_142 = seed.word(45); + const uint64_t v_143 = seed.word(46); + const uint64_t v_144 = seed.word(47); + const uint64_t v_145 = seed.word(48); + const uint64_t v_146 = seed.word(49); + const uint64_t v_147 = seed.word(50); + row[layout.auxiliaries + 35] = v_137; + row[layout.auxiliaries + 36] = v_138; + row[layout.auxiliaries + 37] = v_139; + row[layout.auxiliaries + 38] = v_140; + row[layout.auxiliaries + 39] = v_141; + row[layout.auxiliaries + 40] = v_142; + row[layout.auxiliaries + 41] = v_143; + row[layout.auxiliaries + 42] = v_144; + row[layout.auxiliaries + 43] = v_145; + row[layout.auxiliaries + 44] = v_146; + row[layout.auxiliaries + 45] = v_147; + const uint64_t v_148 = seed.word(51); + const uint64_t v_149 = seed.word(52); + const uint64_t v_150 = seed.word(53); + const uint64_t v_151 = seed.word(54); + const uint64_t v_152 = seed.word(55); + const uint64_t v_153 = seed.word(56); + const uint64_t v_154 = seed.word(57); + const uint64_t v_155 = seed.word(58); + const uint64_t v_156 = seed.word(59); + const uint64_t v_157 = seed.word(60); + const uint64_t v_158 = seed.word(61); + row[layout.auxiliaries + 46] = v_148; + row[layout.auxiliaries + 47] = v_149; + row[layout.auxiliaries + 48] = v_150; + row[layout.auxiliaries + 49] = v_151; + row[layout.auxiliaries + 50] = v_152; + row[layout.auxiliaries + 51] = v_153; + row[layout.auxiliaries + 52] = v_154; + row[layout.auxiliaries + 53] = v_155; + row[layout.auxiliaries + 54] = v_156; + row[layout.auxiliaries + 55] = v_157; + row[layout.auxiliaries + 56] = v_158; + const uint64_t v_159 = seed.word(62); + const uint64_t v_160 = seed.word(63); + const uint64_t v_161 = seed.word(64); + const uint64_t v_162 = seed.word(65); + const uint64_t v_163 = seed.word(66); + const uint64_t v_164 = seed.word(67); + const uint64_t v_165 = seed.word(68); + const uint64_t v_166 = seed.word(69); + const uint64_t v_167 = seed.word(70); + const uint64_t v_168 = seed.word(71); + const uint64_t v_169 = seed.word(72); + row[layout.auxiliaries + 57] = v_159; + row[layout.auxiliaries + 58] = v_160; + row[layout.auxiliaries + 59] = v_161; + row[layout.auxiliaries + 60] = v_162; + row[layout.auxiliaries + 61] = v_163; + row[layout.auxiliaries + 62] = v_164; + row[layout.auxiliaries + 63] = v_165; + row[layout.auxiliaries + 64] = v_166; + row[layout.auxiliaries + 65] = v_167; + row[layout.auxiliaries + 66] = v_168; + row[layout.auxiliaries + 67] = v_169; + const uint64_t v_170 = seed.word(73); + const uint64_t v_171 = seed.word(74); + const uint64_t v_172 = seed.word(75); + const uint64_t v_173 = seed.word(76); + const uint64_t v_174 = seed.word(77); + const uint64_t v_175 = seed.word(78); + const uint64_t v_176 = seed.word(79); + const uint64_t v_177 = seed.word(80); + const uint64_t v_178 = seed.word(81); + const uint64_t v_179 = seed.word(82); + const uint64_t v_180 = seed.word(83); + row[layout.auxiliaries + 68] = v_170; + row[layout.auxiliaries + 69] = v_171; + row[layout.auxiliaries + 70] = v_172; + row[layout.auxiliaries + 71] = v_173; + row[layout.auxiliaries + 72] = v_174; + row[layout.auxiliaries + 73] = v_175; + row[layout.auxiliaries + 74] = v_176; + row[layout.auxiliaries + 75] = v_177; + row[layout.auxiliaries + 76] = v_178; + row[layout.auxiliaries + 77] = v_179; + row[layout.auxiliaries + 78] = v_180; + const uint64_t v_181 = seed.word(84); + const uint64_t v_182 = seed.word(85); + const uint64_t v_183 = seed.word(86); + const uint64_t v_184 = seed.word(87); + const uint64_t v_185 = seed.word(88); + const uint64_t v_186 = seed.word(89); + const uint64_t v_187 = seed.word(90); + const uint64_t v_188 = seed.word(91); + const uint64_t v_189 = seed.word(92); + const uint64_t v_190 = seed.word(93); + const uint64_t v_191 = seed.word(94); + row[layout.auxiliaries + 79] = v_181; + row[layout.auxiliaries + 80] = v_182; + row[layout.auxiliaries + 81] = v_183; + row[layout.auxiliaries + 82] = v_184; + row[layout.auxiliaries + 83] = v_185; + row[layout.auxiliaries + 84] = v_186; + row[layout.auxiliaries + 85] = v_187; + row[layout.auxiliaries + 86] = v_188; + row[layout.auxiliaries + 87] = v_189; + row[layout.auxiliaries + 88] = v_190; + row[layout.auxiliaries + 89] = v_191; + const uint64_t v_201 = seed.word(95); + const uint64_t v_202 = seed.word(96); + const uint64_t v_203 = seed.word(97); + const uint64_t v_204 = seed.word(98); + const uint64_t v_205 = seed.word(99); + const uint64_t v_206 = seed.word(100); + const uint64_t v_207 = seed.word(101); + const uint64_t v_208 = seed.word(102); + const uint64_t v_209 = seed.word(103); + const uint64_t v_210 = seed.word(104); + row[layout.auxiliaries + 90] = v_201; + row[layout.auxiliaries + 91] = v_202; + row[layout.auxiliaries + 92] = v_203; + row[layout.auxiliaries + 93] = v_204; + row[layout.auxiliaries + 94] = v_205; + row[layout.auxiliaries + 95] = v_206; + row[layout.auxiliaries + 96] = v_207; + row[layout.auxiliaries + 97] = v_208; + row[layout.auxiliaries + 98] = v_209; + row[layout.auxiliaries + 99] = v_210; + uint64_t v_217; + switch (v_201) { + case 1ULL: { + const uint64_t v_211 = seed.word(105); + const uint64_t v_212 = seed.word(106); + const uint64_t v_213 = seed.word(107); + row[layout.auxiliaries + 100] = v_211; + row[layout.auxiliaries + 101] = v_212; + row[layout.auxiliaries + 102] = v_213; + switch (v_211) { + case 1ULL: { + const uint64_t v_214 = 1ULL; + row[layout.selectors + 9] = 1; + v_217 = v_214; + goto continuation_9; + } + default: { + row[layout.auxiliaries + 103] = (v_211 <= 1ULL ? inverse_117_10[v_211] : inverse(goldilocks_sub(v_211, 1ULL))); + const uint64_t v_215 = 0ULL; + row[layout.selectors + 10] = 1; + v_217 = v_215; + goto continuation_9; + } + } + } + default: { + row[layout.auxiliaries + 100] = (v_201 <= 1ULL ? inverse_117_11[v_201] : inverse(goldilocks_sub(v_201, 1ULL))); + const uint64_t v_216 = 0ULL; + row[layout.selectors + 11] = 1; + v_217 = v_216; + goto continuation_9; + } + } + continuation_9:; + row[layout.auxiliaries + 104] = v_217; + const uint64_t v_218 = 15ULL; + const uint64_t v_219 = goldilocks_sub(v_2, v_218); + const uint64_t v_220 = uint64_t(v_219 == 0); + row[layout.auxiliaries + 105] = inverse(v_219); + row[layout.auxiliaries + 106] = v_220; + const uint64_t v_221 = uint64_t(v_2 == 0); + row[layout.auxiliaries + 107] = inverse(v_2); + row[layout.auxiliaries + 108] = v_221; + const uint64_t v_222 = goldilocks_mul(v_217, v_220); + row[layout.auxiliaries + 109] = v_222; + const uint64_t v_225 = seed.word(108); + const uint64_t v_226 = seed.word(109); + const uint64_t v_227 = seed.word(110); + const uint64_t v_228 = seed.word(111); + const uint64_t v_229 = seed.word(112); + const uint64_t v_230 = seed.word(113); + const uint64_t v_231 = seed.word(114); + const uint64_t v_232 = seed.word(115); + row[layout.auxiliaries + 110] = v_225; + row[layout.auxiliaries + 111] = v_226; + row[layout.auxiliaries + 112] = v_227; + row[layout.auxiliaries + 113] = v_228; + row[layout.auxiliaries + 114] = v_229; + row[layout.auxiliaries + 115] = v_230; + row[layout.auxiliaries + 116] = v_231; + row[layout.auxiliaries + 117] = v_232; + const uint64_t v_233 = seed.word(116); + row[layout.auxiliaries + 118] = v_233; + const uint64_t v_234 = goldilocks_mul(v_217, v_233); + row[layout.auxiliaries + 119] = v_234; + const uint64_t v_241 = seed.word(117); + const uint64_t v_242 = seed.word(118); + const uint64_t v_243 = seed.word(119); + const uint64_t v_244 = seed.word(120); + const uint64_t v_245 = seed.word(121); + const uint64_t v_246 = seed.word(122); + const uint64_t v_247 = seed.word(123); + const uint64_t v_248 = seed.word(124); + const uint64_t v_249 = seed.word(125); + const uint64_t v_250 = seed.word(126); + const uint64_t v_251 = seed.word(127); + const uint64_t v_252 = seed.word(128); + const uint64_t v_253 = seed.word(129); + const uint64_t v_254 = seed.word(130); + const uint64_t v_255 = seed.word(131); + const uint64_t v_256 = seed.word(132); + const uint64_t v_257 = seed.word(133); + const uint64_t v_258 = seed.word(134); + const uint64_t v_259 = seed.word(135); + const uint64_t v_260 = seed.word(136); + const uint64_t v_261 = seed.word(137); + const uint64_t v_262 = seed.word(138); + const uint64_t v_263 = seed.word(139); + const uint64_t v_264 = seed.word(140); + const uint64_t v_265 = seed.word(141); + const uint64_t v_266 = seed.word(142); + const uint64_t v_267 = seed.word(143); + const uint64_t v_268 = seed.word(144); + const uint64_t v_269 = seed.word(145); + const uint64_t v_270 = seed.word(146); + const uint64_t v_271 = seed.word(147); + const uint64_t v_272 = seed.word(148); + row[layout.auxiliaries + 120] = v_241; + row[layout.auxiliaries + 121] = v_242; + row[layout.auxiliaries + 122] = v_243; + row[layout.auxiliaries + 123] = v_244; + row[layout.auxiliaries + 124] = v_245; + row[layout.auxiliaries + 125] = v_246; + row[layout.auxiliaries + 126] = v_247; + row[layout.auxiliaries + 127] = v_248; + row[layout.auxiliaries + 128] = v_249; + row[layout.auxiliaries + 129] = v_250; + row[layout.auxiliaries + 130] = v_251; + row[layout.auxiliaries + 131] = v_252; + row[layout.auxiliaries + 132] = v_253; + row[layout.auxiliaries + 133] = v_254; + row[layout.auxiliaries + 134] = v_255; + row[layout.auxiliaries + 135] = v_256; + row[layout.auxiliaries + 136] = v_257; + row[layout.auxiliaries + 137] = v_258; + row[layout.auxiliaries + 138] = v_259; + row[layout.auxiliaries + 139] = v_260; + row[layout.auxiliaries + 140] = v_261; + row[layout.auxiliaries + 141] = v_262; + row[layout.auxiliaries + 142] = v_263; + row[layout.auxiliaries + 143] = v_264; + row[layout.auxiliaries + 144] = v_265; + row[layout.auxiliaries + 145] = v_266; + row[layout.auxiliaries + 146] = v_267; + row[layout.auxiliaries + 147] = v_268; + row[layout.auxiliaries + 148] = v_269; + row[layout.auxiliaries + 149] = v_270; + row[layout.auxiliaries + 150] = v_271; + row[layout.auxiliaries + 151] = v_272; + const uint64_t v_289 = seed.word(149); + const uint64_t v_290 = seed.word(150); + const uint64_t v_291 = seed.word(151); + const uint64_t v_292 = seed.word(152); + const uint64_t v_293 = seed.word(153); + const uint64_t v_294 = seed.word(154); + const uint64_t v_295 = seed.word(155); + const uint64_t v_296 = seed.word(156); + const uint64_t v_297 = seed.word(157); + const uint64_t v_298 = seed.word(158); + const uint64_t v_299 = seed.word(159); + const uint64_t v_300 = seed.word(160); + const uint64_t v_301 = seed.word(161); + const uint64_t v_302 = seed.word(162); + const uint64_t v_303 = seed.word(163); + const uint64_t v_304 = seed.word(164); + const uint64_t v_305 = seed.word(165); + const uint64_t v_306 = seed.word(166); + const uint64_t v_307 = seed.word(167); + const uint64_t v_308 = seed.word(168); + const uint64_t v_309 = seed.word(169); + const uint64_t v_310 = seed.word(170); + const uint64_t v_311 = seed.word(171); + const uint64_t v_312 = seed.word(172); + const uint64_t v_313 = seed.word(173); + const uint64_t v_314 = seed.word(174); + const uint64_t v_315 = seed.word(175); + const uint64_t v_316 = seed.word(176); + const uint64_t v_317 = seed.word(177); + const uint64_t v_318 = seed.word(178); + const uint64_t v_319 = seed.word(179); + const uint64_t v_320 = seed.word(180); + row[layout.auxiliaries + 152] = v_289; + row[layout.auxiliaries + 153] = v_290; + row[layout.auxiliaries + 154] = v_291; + row[layout.auxiliaries + 155] = v_292; + row[layout.auxiliaries + 156] = v_293; + row[layout.auxiliaries + 157] = v_294; + row[layout.auxiliaries + 158] = v_295; + row[layout.auxiliaries + 159] = v_296; + row[layout.auxiliaries + 160] = v_297; + row[layout.auxiliaries + 161] = v_298; + row[layout.auxiliaries + 162] = v_299; + row[layout.auxiliaries + 163] = v_300; + row[layout.auxiliaries + 164] = v_301; + row[layout.auxiliaries + 165] = v_302; + row[layout.auxiliaries + 166] = v_303; + row[layout.auxiliaries + 167] = v_304; + row[layout.auxiliaries + 168] = v_305; + row[layout.auxiliaries + 169] = v_306; + row[layout.auxiliaries + 170] = v_307; + row[layout.auxiliaries + 171] = v_308; + row[layout.auxiliaries + 172] = v_309; + row[layout.auxiliaries + 173] = v_310; + row[layout.auxiliaries + 174] = v_311; + row[layout.auxiliaries + 175] = v_312; + row[layout.auxiliaries + 176] = v_313; + row[layout.auxiliaries + 177] = v_314; + row[layout.auxiliaries + 178] = v_315; + row[layout.auxiliaries + 179] = v_316; + row[layout.auxiliaries + 180] = v_317; + row[layout.auxiliaries + 181] = v_318; + row[layout.auxiliaries + 182] = v_319; + row[layout.auxiliaries + 183] = v_320; + switch (v_217) { + case 1ULL: { + const uint64_t v_322 = seed.word(181); + row[layout.auxiliaries + 184] = v_322; + row[layout.selectors + 12] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 184] = (v_217 <= 1ULL ? inverse_117_12[v_217] : inverse(goldilocks_sub(v_217, 1ULL))); + switch (v_220) { + case 1ULL: { + const uint64_t v_355 = seed.word(181); + const uint64_t v_356 = seed.word(182); + const uint64_t v_357 = seed.word(183); + const uint64_t v_358 = seed.word(184); + const uint64_t v_359 = seed.word(185); + const uint64_t v_360 = seed.word(186); + const uint64_t v_361 = seed.word(187); + const uint64_t v_362 = seed.word(188); + row[layout.auxiliaries + 185] = v_355; + row[layout.auxiliaries + 186] = v_356; + row[layout.auxiliaries + 187] = v_357; + row[layout.auxiliaries + 188] = v_358; + row[layout.auxiliaries + 189] = v_359; + row[layout.auxiliaries + 190] = v_360; + row[layout.auxiliaries + 191] = v_361; + row[layout.auxiliaries + 192] = v_362; + const uint64_t v_363 = seed.word(189); + const uint64_t v_364 = seed.word(190); + const uint64_t v_365 = seed.word(191); + const uint64_t v_366 = seed.word(192); + const uint64_t v_367 = seed.word(193); + const uint64_t v_368 = seed.word(194); + const uint64_t v_369 = seed.word(195); + const uint64_t v_370 = seed.word(196); + row[layout.auxiliaries + 193] = v_363; + row[layout.auxiliaries + 194] = v_364; + row[layout.auxiliaries + 195] = v_365; + row[layout.auxiliaries + 196] = v_366; + row[layout.auxiliaries + 197] = v_367; + row[layout.auxiliaries + 198] = v_368; + row[layout.auxiliaries + 199] = v_369; + row[layout.auxiliaries + 200] = v_370; + const uint64_t v_371 = seed.word(197); + row[layout.auxiliaries + 201] = v_371; + const uint64_t v_372 = seed.word(198); + row[layout.auxiliaries + 202] = v_372; + const uint64_t v_373 = seed.word(199); + row[layout.auxiliaries + 203] = v_373; + const uint64_t v_374 = seed.word(200); + row[layout.auxiliaries + 204] = v_374; + row[layout.selectors + 13] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 185] = (v_220 <= 1ULL ? inverse_117_13[v_220] : inverse(goldilocks_sub(v_220, 1ULL))); + const uint64_t v_377 = seed.word(181); + row[layout.auxiliaries + 186] = v_377; + const uint64_t v_378 = seed.word(182); + row[layout.auxiliaries + 187] = v_378; + row[layout.selectors + 14] = 1; + return 0; + } + } + } + } + } + } +} +template __global__ void kernel_ix_aggr_117(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 544 : 1608; + const Seed_ix_aggr_117 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_117(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_117(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_117<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_117<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_117(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 15 || width < auxiliaries || width - auxiliaries < 205) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 544 : encoding == 0 ? 1608 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_117); +} + +template struct Seed_ix_aggr_220 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 32); + case 4: return load_u32(data + 16); + case 5: return load_u32(data + 20); + case 6: return load_u8(data + 33); + case 7: return load_u32(data + 24); + case 8: return load_u32(data + 28); + case 9: return load_u8(data + 34); + case 10: return load_u8(data + 35); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_220(Seed_ix_aggr_220 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_9 = seed.word(6); + const uint64_t v_10 = seed.word(7); + const uint64_t v_11 = seed.word(8); + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + switch (v_9) { + case 0ULL: { + const uint64_t v_12 = seed.word(9); + row[layout.auxiliaries + 7] = v_12; + const uint64_t v_14 = seed.word(10); + row[layout.auxiliaries + 8] = v_14; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ix_aggr_220(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 88; + const Seed_ix_aggr_220 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_220(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_220(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_220<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_220<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_220(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_220); +} + +template struct Seed_ix_aggr_230 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 72); + case 2: return load_u8(data + 73); + case 3: return load_u8(data + 74); + case 4: return load_u8(data + 75); + case 5: return load_u8(data + 76); + case 6: return load_u8(data + 77); + case 7: return load_u8(data + 78); + case 8: return load_u8(data + 79); + case 9: return load_u8(data + 80); + case 10: return load_u8(data + 81); + case 11: return load_u8(data + 82); + case 12: return load_u8(data + 83); + case 13: return load_u8(data + 84); + case 14: return load_u8(data + 85); + case 15: return load_u8(data + 86); + case 16: return load_u8(data + 87); + case 17: return load_u64(data + 8); + case 18: return load_u64(data + 16); + case 19: return load_u64(data + 24); + case 20: return load_u64(data + 32); + case 21: return load_u64(data + 40); + case 22: return load_u64(data + 48); + case 23: return load_u64(data + 56); + case 24: return load_u64(data + 64); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_230(Seed_ix_aggr_230 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_17 = seed.word(17); + row[layout.auxiliaries + 1] = v_17; + const uint64_t v_18 = seed.word(18); + row[layout.auxiliaries + 2] = v_18; + const uint64_t v_19 = seed.word(19); + row[layout.auxiliaries + 3] = v_19; + const uint64_t v_20 = seed.word(20); + row[layout.auxiliaries + 4] = v_20; + const uint64_t v_21 = seed.word(21); + row[layout.auxiliaries + 5] = v_21; + const uint64_t v_22 = seed.word(22); + row[layout.auxiliaries + 6] = v_22; + const uint64_t v_23 = seed.word(23); + row[layout.auxiliaries + 7] = v_23; + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 8] = v_24; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ix_aggr_230(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 88 : 200; + const Seed_ix_aggr_230 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_230(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_230(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_230<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_230<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_230(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 200 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_230); +} + +extern "C" const uint8_t* aiur_trace_ix_aggr_contract() { + static const uint8_t hash[32] = {192, 114, 108, 80, 224, 251, 146, 62, 231, 56, 127, 105, 147, 26, 68, 117, 241, 169, 63, 124, 221, 174, 220, 212, 61, 234, 92, 95, 60, 118, 170, 102}; + return hash; +} +extern "C" const uint8_t* aiur_trace_ix_aggr_schema() { + static const uint8_t hash[32] = {249, 214, 235, 36, 170, 180, 109, 126, 100, 46, 206, 6, 228, 84, 34, 205, 31, 35, 197, 64, 229, 223, 94, 246, 213, 87, 208, 102, 251, 132, 31, 243}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/ixvm.cu b/crates/aiur/cuda/generated/production/ixvm.cu new file mode 100644 index 000000000..5611cc5f6 --- /dev/null +++ b/crates/aiur/cuda/generated/production/ixvm.cu @@ -0,0 +1,8608 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_ixvm { +using namespace aiur_trace; + +template struct Seed_ixvm_16 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + case 13: return load_u8(data + 20); + case 14: return load_u8(data + 21); + case 15: return load_u8(data + 22); + case 16: return load_u8(data + 23); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_16(Seed_ixvm_16 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + if (v_0 > 255 || v_8 > 255) return 1; + const uint64_t v_16 = ((v_0 + v_8) & 255ULL); + const uint64_t v_17 = ((v_0 + v_8) >> 8); + row[layout.auxiliaries + 1] = v_16; + if (v_1 > 255 || v_9 > 255) return 1; + const uint64_t v_18 = ((v_1 + v_9) & 255ULL); + const uint64_t v_19 = ((v_1 + v_9) >> 8); + row[layout.auxiliaries + 2] = v_18; + if (v_18 > 255 || v_17 > 255) return 1; + const uint64_t v_20 = ((v_18 + v_17) & 255ULL); + const uint64_t v_21 = ((v_18 + v_17) >> 8); + row[layout.auxiliaries + 3] = v_20; + const uint64_t v_22 = goldilocks_add(v_19, v_21); + if (v_2 > 255 || v_10 > 255) return 1; + const uint64_t v_23 = ((v_2 + v_10) & 255ULL); + const uint64_t v_24 = ((v_2 + v_10) >> 8); + row[layout.auxiliaries + 4] = v_23; + if (v_23 > 255 || v_22 > 255) return 1; + const uint64_t v_25 = ((v_23 + v_22) & 255ULL); + const uint64_t v_26 = ((v_23 + v_22) >> 8); + row[layout.auxiliaries + 5] = v_25; + const uint64_t v_27 = goldilocks_add(v_24, v_26); + if (v_3 > 255 || v_11 > 255) return 1; + const uint64_t v_28 = ((v_3 + v_11) & 255ULL); + const uint64_t v_29 = ((v_3 + v_11) >> 8); + row[layout.auxiliaries + 6] = v_28; + if (v_28 > 255 || v_27 > 255) return 1; + const uint64_t v_30 = ((v_28 + v_27) & 255ULL); + const uint64_t v_31 = ((v_28 + v_27) >> 8); + row[layout.auxiliaries + 7] = v_30; + const uint64_t v_32 = goldilocks_add(v_29, v_31); + if (v_4 > 255 || v_12 > 255) return 1; + const uint64_t v_33 = ((v_4 + v_12) & 255ULL); + const uint64_t v_34 = ((v_4 + v_12) >> 8); + row[layout.auxiliaries + 8] = v_33; + if (v_33 > 255 || v_32 > 255) return 1; + const uint64_t v_35 = ((v_33 + v_32) & 255ULL); + const uint64_t v_36 = ((v_33 + v_32) >> 8); + row[layout.auxiliaries + 9] = v_35; + const uint64_t v_37 = goldilocks_add(v_34, v_36); + if (v_5 > 255 || v_13 > 255) return 1; + const uint64_t v_38 = ((v_5 + v_13) & 255ULL); + const uint64_t v_39 = ((v_5 + v_13) >> 8); + row[layout.auxiliaries + 10] = v_38; + if (v_38 > 255 || v_37 > 255) return 1; + const uint64_t v_40 = ((v_38 + v_37) & 255ULL); + const uint64_t v_41 = ((v_38 + v_37) >> 8); + row[layout.auxiliaries + 11] = v_40; + const uint64_t v_42 = goldilocks_add(v_39, v_41); + if (v_6 > 255 || v_14 > 255) return 1; + const uint64_t v_43 = ((v_6 + v_14) & 255ULL); + const uint64_t v_44 = ((v_6 + v_14) >> 8); + row[layout.auxiliaries + 12] = v_43; + if (v_43 > 255 || v_42 > 255) return 1; + const uint64_t v_45 = ((v_43 + v_42) & 255ULL); + const uint64_t v_46 = ((v_43 + v_42) >> 8); + row[layout.auxiliaries + 13] = v_45; + const uint64_t v_47 = goldilocks_add(v_44, v_46); + if (v_7 > 255 || v_15 > 255) return 1; + const uint64_t v_48 = ((v_7 + v_15) & 255ULL); + const uint64_t v_49 = ((v_7 + v_15) >> 8); + row[layout.auxiliaries + 14] = v_48; + if (v_48 > 255 || v_47 > 255) return 1; + const uint64_t v_50 = ((v_48 + v_47) & 255ULL); + const uint64_t v_51 = ((v_48 + v_47) >> 8); + row[layout.auxiliaries + 15] = v_50; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_16(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 136; + const Seed_ixvm_16 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_16(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_16(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_16<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_16<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_16(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_16); +} + +template struct Seed_ixvm_27 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 56); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 72); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 60); + case 6: return load_u32(data + 64); + case 7: return load_u64(data + 24); + case 8: return load_u8(data + 73); + case 9: return load_u64(data + 32); + case 10: return load_u32(data + 68); + case 11: return load_u64(data + 40); + case 12: return load_u64(data + 48); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_27(Seed_ixvm_27 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 1] = v_7; + row[layout.auxiliaries + 2] = v_8; + row[layout.auxiliaries + 3] = v_9; + switch (v_7) { + case 1ULL: { + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 4] = v_10; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(11); + row[layout.auxiliaries + 4] = v_12; + switch (v_2) { + case 63ULL: { + const uint64_t v_13 = seed.word(12); + row[layout.auxiliaries + 5] = v_13; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 5] = inverse(goldilocks_sub(v_2, 63ULL)); + const uint64_t v_17 = seed.word(12); + row[layout.auxiliaries + 6] = v_17; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_27(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 80 : 104; + const Seed_ixvm_27 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_27(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_27(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_27<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_27<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_27(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 7 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 80 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_27); +} + +template struct Seed_ixvm_28 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 528); + case 2: return load_u8(data + 784); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 532); + case 5: return load_u8(data + 785); + case 6: return load_u64(data + 16); + case 7: return load_u32(data + 536); + case 8: return load_u8(data + 786); + case 9: return load_u64(data + 24); + case 10: return load_u32(data + 540); + case 11: return load_u8(data + 787); + case 12: return load_u64(data + 32); + case 13: return load_u32(data + 544); + case 14: return load_u8(data + 788); + case 15: return load_u64(data + 40); + case 16: return load_u32(data + 548); + case 17: return load_u8(data + 789); + case 18: return load_u64(data + 48); + case 19: return load_u32(data + 552); + case 20: return load_u8(data + 790); + case 21: return load_u64(data + 56); + case 22: return load_u32(data + 556); + case 23: return load_u8(data + 791); + case 24: return load_u64(data + 64); + case 25: return load_u32(data + 560); + case 26: return load_u8(data + 792); + case 27: return load_u64(data + 72); + case 28: return load_u32(data + 564); + case 29: return load_u8(data + 793); + case 30: return load_u64(data + 80); + case 31: return load_u32(data + 568); + case 32: return load_u8(data + 794); + case 33: return load_u64(data + 88); + case 34: return load_u32(data + 572); + case 35: return load_u8(data + 795); + case 36: return load_u64(data + 96); + case 37: return load_u32(data + 576); + case 38: return load_u8(data + 796); + case 39: return load_u64(data + 104); + case 40: return load_u32(data + 580); + case 41: return load_u8(data + 797); + case 42: return load_u64(data + 112); + case 43: return load_u32(data + 584); + case 44: return load_u8(data + 798); + case 45: return load_u64(data + 120); + case 46: return load_u32(data + 588); + case 47: return load_u8(data + 799); + case 48: return load_u64(data + 128); + case 49: return load_u32(data + 592); + case 50: return load_u8(data + 800); + case 51: return load_u64(data + 136); + case 52: return load_u32(data + 596); + case 53: return load_u8(data + 801); + case 54: return load_u64(data + 144); + case 55: return load_u32(data + 600); + case 56: return load_u8(data + 802); + case 57: return load_u64(data + 152); + case 58: return load_u32(data + 604); + case 59: return load_u8(data + 803); + case 60: return load_u64(data + 160); + case 61: return load_u32(data + 608); + case 62: return load_u8(data + 804); + case 63: return load_u64(data + 168); + case 64: return load_u32(data + 612); + case 65: return load_u8(data + 805); + case 66: return load_u64(data + 176); + case 67: return load_u32(data + 616); + case 68: return load_u8(data + 806); + case 69: return load_u64(data + 184); + case 70: return load_u32(data + 620); + case 71: return load_u8(data + 807); + case 72: return load_u64(data + 192); + case 73: return load_u32(data + 624); + case 74: return load_u8(data + 808); + case 75: return load_u64(data + 200); + case 76: return load_u32(data + 628); + case 77: return load_u8(data + 809); + case 78: return load_u64(data + 208); + case 79: return load_u32(data + 632); + case 80: return load_u8(data + 810); + case 81: return load_u64(data + 216); + case 82: return load_u32(data + 636); + case 83: return load_u8(data + 811); + case 84: return load_u64(data + 224); + case 85: return load_u32(data + 640); + case 86: return load_u8(data + 812); + case 87: return load_u64(data + 232); + case 88: return load_u32(data + 644); + case 89: return load_u8(data + 813); + case 90: return load_u64(data + 240); + case 91: return load_u32(data + 648); + case 92: return load_u8(data + 814); + case 93: return load_u64(data + 248); + case 94: return load_u32(data + 652); + case 95: return load_u8(data + 815); + case 96: return load_u64(data + 256); + case 97: return load_u32(data + 656); + case 98: return load_u8(data + 816); + case 99: return load_u64(data + 264); + case 100: return load_u32(data + 660); + case 101: return load_u8(data + 817); + case 102: return load_u64(data + 272); + case 103: return load_u32(data + 664); + case 104: return load_u8(data + 818); + case 105: return load_u64(data + 280); + case 106: return load_u32(data + 668); + case 107: return load_u8(data + 819); + case 108: return load_u64(data + 288); + case 109: return load_u32(data + 672); + case 110: return load_u8(data + 820); + case 111: return load_u64(data + 296); + case 112: return load_u32(data + 676); + case 113: return load_u8(data + 821); + case 114: return load_u64(data + 304); + case 115: return load_u32(data + 680); + case 116: return load_u8(data + 822); + case 117: return load_u64(data + 312); + case 118: return load_u32(data + 684); + case 119: return load_u8(data + 823); + case 120: return load_u64(data + 320); + case 121: return load_u32(data + 688); + case 122: return load_u8(data + 824); + case 123: return load_u64(data + 328); + case 124: return load_u32(data + 692); + case 125: return load_u8(data + 825); + case 126: return load_u64(data + 336); + case 127: return load_u32(data + 696); + case 128: return load_u8(data + 826); + case 129: return load_u64(data + 344); + case 130: return load_u32(data + 700); + case 131: return load_u8(data + 827); + case 132: return load_u64(data + 352); + case 133: return load_u32(data + 704); + case 134: return load_u8(data + 828); + case 135: return load_u64(data + 360); + case 136: return load_u32(data + 708); + case 137: return load_u8(data + 829); + case 138: return load_u64(data + 368); + case 139: return load_u32(data + 712); + case 140: return load_u8(data + 830); + case 141: return load_u64(data + 376); + case 142: return load_u32(data + 716); + case 143: return load_u8(data + 831); + case 144: return load_u64(data + 384); + case 145: return load_u32(data + 720); + case 146: return load_u8(data + 832); + case 147: return load_u64(data + 392); + case 148: return load_u32(data + 724); + case 149: return load_u8(data + 833); + case 150: return load_u64(data + 400); + case 151: return load_u32(data + 728); + case 152: return load_u8(data + 834); + case 153: return load_u64(data + 408); + case 154: return load_u32(data + 732); + case 155: return load_u8(data + 835); + case 156: return load_u64(data + 416); + case 157: return load_u32(data + 736); + case 158: return load_u8(data + 836); + case 159: return load_u64(data + 424); + case 160: return load_u32(data + 740); + case 161: return load_u8(data + 837); + case 162: return load_u64(data + 432); + case 163: return load_u32(data + 744); + case 164: return load_u8(data + 838); + case 165: return load_u64(data + 440); + case 166: return load_u32(data + 748); + case 167: return load_u8(data + 839); + case 168: return load_u64(data + 448); + case 169: return load_u32(data + 752); + case 170: return load_u8(data + 840); + case 171: return load_u64(data + 456); + case 172: return load_u32(data + 756); + case 173: return load_u8(data + 841); + case 174: return load_u64(data + 464); + case 175: return load_u32(data + 760); + case 176: return load_u8(data + 842); + case 177: return load_u64(data + 472); + case 178: return load_u32(data + 764); + case 179: return load_u8(data + 843); + case 180: return load_u64(data + 480); + case 181: return load_u32(data + 768); + case 182: return load_u8(data + 844); + case 183: return load_u64(data + 488); + case 184: return load_u32(data + 772); + case 185: return load_u8(data + 845); + case 186: return load_u64(data + 496); + case 187: return load_u32(data + 776); + case 188: return load_u8(data + 846); + case 189: return load_u64(data + 504); + case 190: return load_u32(data + 780); + case 191: return load_u8(data + 847); + case 192: return load_u64(data + 512); + case 193: return load_u64(data + 520); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_28(Seed_ixvm_28 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + switch (v_4) { + case 0ULL: { + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + switch (v_7) { + case 0ULL: { + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + switch (v_10) { + case 0ULL: { + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + switch (v_13) { + case 0ULL: { + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + switch (v_16) { + case 0ULL: { + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + row[layout.auxiliaries + 19] = v_19; + row[layout.auxiliaries + 20] = v_20; + row[layout.auxiliaries + 21] = v_21; + switch (v_19) { + case 0ULL: { + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 22] = v_22; + row[layout.auxiliaries + 23] = v_23; + row[layout.auxiliaries + 24] = v_24; + switch (v_22) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 25] = v_25; + row[layout.auxiliaries + 26] = v_26; + row[layout.auxiliaries + 27] = v_27; + switch (v_25) { + case 0ULL: { + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 28] = v_28; + row[layout.auxiliaries + 29] = v_29; + row[layout.auxiliaries + 30] = v_30; + switch (v_28) { + case 0ULL: { + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + row[layout.auxiliaries + 31] = v_31; + row[layout.auxiliaries + 32] = v_32; + row[layout.auxiliaries + 33] = v_33; + switch (v_31) { + case 0ULL: { + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 34] = v_34; + row[layout.auxiliaries + 35] = v_35; + row[layout.auxiliaries + 36] = v_36; + switch (v_34) { + case 0ULL: { + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + row[layout.auxiliaries + 37] = v_37; + row[layout.auxiliaries + 38] = v_38; + row[layout.auxiliaries + 39] = v_39; + switch (v_37) { + case 0ULL: { + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + row[layout.auxiliaries + 40] = v_40; + row[layout.auxiliaries + 41] = v_41; + row[layout.auxiliaries + 42] = v_42; + switch (v_40) { + case 0ULL: { + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + row[layout.auxiliaries + 43] = v_43; + row[layout.auxiliaries + 44] = v_44; + row[layout.auxiliaries + 45] = v_45; + switch (v_43) { + case 0ULL: { + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 46] = v_46; + row[layout.auxiliaries + 47] = v_47; + row[layout.auxiliaries + 48] = v_48; + switch (v_46) { + case 0ULL: { + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 49] = v_49; + row[layout.auxiliaries + 50] = v_50; + row[layout.auxiliaries + 51] = v_51; + switch (v_49) { + case 0ULL: { + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + row[layout.auxiliaries + 52] = v_52; + row[layout.auxiliaries + 53] = v_53; + row[layout.auxiliaries + 54] = v_54; + switch (v_52) { + case 0ULL: { + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + const uint64_t v_57 = seed.word(58); + row[layout.auxiliaries + 55] = v_55; + row[layout.auxiliaries + 56] = v_56; + row[layout.auxiliaries + 57] = v_57; + switch (v_55) { + case 0ULL: { + const uint64_t v_58 = seed.word(59); + const uint64_t v_59 = seed.word(60); + const uint64_t v_60 = seed.word(61); + row[layout.auxiliaries + 58] = v_58; + row[layout.auxiliaries + 59] = v_59; + row[layout.auxiliaries + 60] = v_60; + switch (v_58) { + case 0ULL: { + const uint64_t v_61 = seed.word(62); + const uint64_t v_62 = seed.word(63); + const uint64_t v_63 = seed.word(64); + row[layout.auxiliaries + 61] = v_61; + row[layout.auxiliaries + 62] = v_62; + row[layout.auxiliaries + 63] = v_63; + switch (v_61) { + case 0ULL: { + const uint64_t v_64 = seed.word(65); + const uint64_t v_65 = seed.word(66); + const uint64_t v_66 = seed.word(67); + row[layout.auxiliaries + 64] = v_64; + row[layout.auxiliaries + 65] = v_65; + row[layout.auxiliaries + 66] = v_66; + switch (v_64) { + case 0ULL: { + const uint64_t v_67 = seed.word(68); + const uint64_t v_68 = seed.word(69); + const uint64_t v_69 = seed.word(70); + row[layout.auxiliaries + 67] = v_67; + row[layout.auxiliaries + 68] = v_68; + row[layout.auxiliaries + 69] = v_69; + switch (v_67) { + case 0ULL: { + const uint64_t v_70 = seed.word(71); + const uint64_t v_71 = seed.word(72); + const uint64_t v_72 = seed.word(73); + row[layout.auxiliaries + 70] = v_70; + row[layout.auxiliaries + 71] = v_71; + row[layout.auxiliaries + 72] = v_72; + switch (v_70) { + case 0ULL: { + const uint64_t v_73 = seed.word(74); + const uint64_t v_74 = seed.word(75); + const uint64_t v_75 = seed.word(76); + row[layout.auxiliaries + 73] = v_73; + row[layout.auxiliaries + 74] = v_74; + row[layout.auxiliaries + 75] = v_75; + switch (v_73) { + case 0ULL: { + const uint64_t v_76 = seed.word(77); + const uint64_t v_77 = seed.word(78); + const uint64_t v_78 = seed.word(79); + row[layout.auxiliaries + 76] = v_76; + row[layout.auxiliaries + 77] = v_77; + row[layout.auxiliaries + 78] = v_78; + switch (v_76) { + case 0ULL: { + const uint64_t v_79 = seed.word(80); + const uint64_t v_80 = seed.word(81); + const uint64_t v_81 = seed.word(82); + row[layout.auxiliaries + 79] = v_79; + row[layout.auxiliaries + 80] = v_80; + row[layout.auxiliaries + 81] = v_81; + switch (v_79) { + case 0ULL: { + const uint64_t v_82 = seed.word(83); + const uint64_t v_83 = seed.word(84); + const uint64_t v_84 = seed.word(85); + row[layout.auxiliaries + 82] = v_82; + row[layout.auxiliaries + 83] = v_83; + row[layout.auxiliaries + 84] = v_84; + switch (v_82) { + case 0ULL: { + const uint64_t v_85 = seed.word(86); + const uint64_t v_86 = seed.word(87); + const uint64_t v_87 = seed.word(88); + row[layout.auxiliaries + 85] = v_85; + row[layout.auxiliaries + 86] = v_86; + row[layout.auxiliaries + 87] = v_87; + switch (v_85) { + case 0ULL: { + const uint64_t v_88 = seed.word(89); + const uint64_t v_89 = seed.word(90); + const uint64_t v_90 = seed.word(91); + row[layout.auxiliaries + 88] = v_88; + row[layout.auxiliaries + 89] = v_89; + row[layout.auxiliaries + 90] = v_90; + switch (v_88) { + case 0ULL: { + const uint64_t v_91 = seed.word(92); + const uint64_t v_92 = seed.word(93); + const uint64_t v_93 = seed.word(94); + row[layout.auxiliaries + 91] = v_91; + row[layout.auxiliaries + 92] = v_92; + row[layout.auxiliaries + 93] = v_93; + switch (v_91) { + case 0ULL: { + const uint64_t v_94 = seed.word(95); + const uint64_t v_95 = seed.word(96); + const uint64_t v_96 = seed.word(97); + row[layout.auxiliaries + 94] = v_94; + row[layout.auxiliaries + 95] = v_95; + row[layout.auxiliaries + 96] = v_96; + switch (v_94) { + case 0ULL: { + const uint64_t v_97 = seed.word(98); + const uint64_t v_98 = seed.word(99); + const uint64_t v_99 = seed.word(100); + row[layout.auxiliaries + 97] = v_97; + row[layout.auxiliaries + 98] = v_98; + row[layout.auxiliaries + 99] = v_99; + switch (v_97) { + case 0ULL: { + const uint64_t v_100 = seed.word(101); + const uint64_t v_101 = seed.word(102); + const uint64_t v_102 = seed.word(103); + row[layout.auxiliaries + 100] = v_100; + row[layout.auxiliaries + 101] = v_101; + row[layout.auxiliaries + 102] = v_102; + switch (v_100) { + case 0ULL: { + const uint64_t v_103 = seed.word(104); + const uint64_t v_104 = seed.word(105); + const uint64_t v_105 = seed.word(106); + row[layout.auxiliaries + 103] = v_103; + row[layout.auxiliaries + 104] = v_104; + row[layout.auxiliaries + 105] = v_105; + switch (v_103) { + case 0ULL: { + const uint64_t v_106 = seed.word(107); + const uint64_t v_107 = seed.word(108); + const uint64_t v_108 = seed.word(109); + row[layout.auxiliaries + 106] = v_106; + row[layout.auxiliaries + 107] = v_107; + row[layout.auxiliaries + 108] = v_108; + switch (v_106) { + case 0ULL: { + const uint64_t v_109 = seed.word(110); + const uint64_t v_110 = seed.word(111); + const uint64_t v_111 = seed.word(112); + row[layout.auxiliaries + 109] = v_109; + row[layout.auxiliaries + 110] = v_110; + row[layout.auxiliaries + 111] = v_111; + switch (v_109) { + case 0ULL: { + const uint64_t v_112 = seed.word(113); + const uint64_t v_113 = seed.word(114); + const uint64_t v_114 = seed.word(115); + row[layout.auxiliaries + 112] = v_112; + row[layout.auxiliaries + 113] = v_113; + row[layout.auxiliaries + 114] = v_114; + switch (v_112) { + case 0ULL: { + const uint64_t v_115 = seed.word(116); + const uint64_t v_116 = seed.word(117); + const uint64_t v_117 = seed.word(118); + row[layout.auxiliaries + 115] = v_115; + row[layout.auxiliaries + 116] = v_116; + row[layout.auxiliaries + 117] = v_117; + switch (v_115) { + case 0ULL: { + const uint64_t v_118 = seed.word(119); + const uint64_t v_119 = seed.word(120); + const uint64_t v_120 = seed.word(121); + row[layout.auxiliaries + 118] = v_118; + row[layout.auxiliaries + 119] = v_119; + row[layout.auxiliaries + 120] = v_120; + switch (v_118) { + case 0ULL: { + const uint64_t v_121 = seed.word(122); + const uint64_t v_122 = seed.word(123); + const uint64_t v_123 = seed.word(124); + row[layout.auxiliaries + 121] = v_121; + row[layout.auxiliaries + 122] = v_122; + row[layout.auxiliaries + 123] = v_123; + switch (v_121) { + case 0ULL: { + const uint64_t v_124 = seed.word(125); + const uint64_t v_125 = seed.word(126); + const uint64_t v_126 = seed.word(127); + row[layout.auxiliaries + 124] = v_124; + row[layout.auxiliaries + 125] = v_125; + row[layout.auxiliaries + 126] = v_126; + switch (v_124) { + case 0ULL: { + const uint64_t v_127 = seed.word(128); + const uint64_t v_128 = seed.word(129); + const uint64_t v_129 = seed.word(130); + row[layout.auxiliaries + 127] = v_127; + row[layout.auxiliaries + 128] = v_128; + row[layout.auxiliaries + 129] = v_129; + switch (v_127) { + case 0ULL: { + const uint64_t v_130 = seed.word(131); + const uint64_t v_131 = seed.word(132); + const uint64_t v_132 = seed.word(133); + row[layout.auxiliaries + 130] = v_130; + row[layout.auxiliaries + 131] = v_131; + row[layout.auxiliaries + 132] = v_132; + switch (v_130) { + case 0ULL: { + const uint64_t v_133 = seed.word(134); + const uint64_t v_134 = seed.word(135); + const uint64_t v_135 = seed.word(136); + row[layout.auxiliaries + 133] = v_133; + row[layout.auxiliaries + 134] = v_134; + row[layout.auxiliaries + 135] = v_135; + switch (v_133) { + case 0ULL: { + const uint64_t v_136 = seed.word(137); + const uint64_t v_137 = seed.word(138); + const uint64_t v_138 = seed.word(139); + row[layout.auxiliaries + 136] = v_136; + row[layout.auxiliaries + 137] = v_137; + row[layout.auxiliaries + 138] = v_138; + switch (v_136) { + case 0ULL: { + const uint64_t v_139 = seed.word(140); + const uint64_t v_140 = seed.word(141); + const uint64_t v_141 = seed.word(142); + row[layout.auxiliaries + 139] = v_139; + row[layout.auxiliaries + 140] = v_140; + row[layout.auxiliaries + 141] = v_141; + switch (v_139) { + case 0ULL: { + const uint64_t v_142 = seed.word(143); + const uint64_t v_143 = seed.word(144); + const uint64_t v_144 = seed.word(145); + row[layout.auxiliaries + 142] = v_142; + row[layout.auxiliaries + 143] = v_143; + row[layout.auxiliaries + 144] = v_144; + switch (v_142) { + case 0ULL: { + const uint64_t v_145 = seed.word(146); + const uint64_t v_146 = seed.word(147); + const uint64_t v_147 = seed.word(148); + row[layout.auxiliaries + 145] = v_145; + row[layout.auxiliaries + 146] = v_146; + row[layout.auxiliaries + 147] = v_147; + switch (v_145) { + case 0ULL: { + const uint64_t v_148 = seed.word(149); + const uint64_t v_149 = seed.word(150); + const uint64_t v_150 = seed.word(151); + row[layout.auxiliaries + 148] = v_148; + row[layout.auxiliaries + 149] = v_149; + row[layout.auxiliaries + 150] = v_150; + switch (v_148) { + case 0ULL: { + const uint64_t v_151 = seed.word(152); + const uint64_t v_152 = seed.word(153); + const uint64_t v_153 = seed.word(154); + row[layout.auxiliaries + 151] = v_151; + row[layout.auxiliaries + 152] = v_152; + row[layout.auxiliaries + 153] = v_153; + switch (v_151) { + case 0ULL: { + const uint64_t v_154 = seed.word(155); + const uint64_t v_155 = seed.word(156); + const uint64_t v_156 = seed.word(157); + row[layout.auxiliaries + 154] = v_154; + row[layout.auxiliaries + 155] = v_155; + row[layout.auxiliaries + 156] = v_156; + switch (v_154) { + case 0ULL: { + const uint64_t v_157 = seed.word(158); + const uint64_t v_158 = seed.word(159); + const uint64_t v_159 = seed.word(160); + row[layout.auxiliaries + 157] = v_157; + row[layout.auxiliaries + 158] = v_158; + row[layout.auxiliaries + 159] = v_159; + switch (v_157) { + case 0ULL: { + const uint64_t v_160 = seed.word(161); + const uint64_t v_161 = seed.word(162); + const uint64_t v_162 = seed.word(163); + row[layout.auxiliaries + 160] = v_160; + row[layout.auxiliaries + 161] = v_161; + row[layout.auxiliaries + 162] = v_162; + switch (v_160) { + case 0ULL: { + const uint64_t v_163 = seed.word(164); + const uint64_t v_164 = seed.word(165); + const uint64_t v_165 = seed.word(166); + row[layout.auxiliaries + 163] = v_163; + row[layout.auxiliaries + 164] = v_164; + row[layout.auxiliaries + 165] = v_165; + switch (v_163) { + case 0ULL: { + const uint64_t v_166 = seed.word(167); + const uint64_t v_167 = seed.word(168); + const uint64_t v_168 = seed.word(169); + row[layout.auxiliaries + 166] = v_166; + row[layout.auxiliaries + 167] = v_167; + row[layout.auxiliaries + 168] = v_168; + switch (v_166) { + case 0ULL: { + const uint64_t v_169 = seed.word(170); + const uint64_t v_170 = seed.word(171); + const uint64_t v_171 = seed.word(172); + row[layout.auxiliaries + 169] = v_169; + row[layout.auxiliaries + 170] = v_170; + row[layout.auxiliaries + 171] = v_171; + switch (v_169) { + case 0ULL: { + const uint64_t v_172 = seed.word(173); + const uint64_t v_173 = seed.word(174); + const uint64_t v_174 = seed.word(175); + row[layout.auxiliaries + 172] = v_172; + row[layout.auxiliaries + 173] = v_173; + row[layout.auxiliaries + 174] = v_174; + switch (v_172) { + case 0ULL: { + const uint64_t v_175 = seed.word(176); + const uint64_t v_176 = seed.word(177); + const uint64_t v_177 = seed.word(178); + row[layout.auxiliaries + 175] = v_175; + row[layout.auxiliaries + 176] = v_176; + row[layout.auxiliaries + 177] = v_177; + switch (v_175) { + case 0ULL: { + const uint64_t v_178 = seed.word(179); + const uint64_t v_179 = seed.word(180); + const uint64_t v_180 = seed.word(181); + row[layout.auxiliaries + 178] = v_178; + row[layout.auxiliaries + 179] = v_179; + row[layout.auxiliaries + 180] = v_180; + switch (v_178) { + case 0ULL: { + const uint64_t v_181 = seed.word(182); + const uint64_t v_182 = seed.word(183); + const uint64_t v_183 = seed.word(184); + row[layout.auxiliaries + 181] = v_181; + row[layout.auxiliaries + 182] = v_182; + row[layout.auxiliaries + 183] = v_183; + switch (v_181) { + case 0ULL: { + const uint64_t v_184 = seed.word(185); + const uint64_t v_185 = seed.word(186); + const uint64_t v_186 = seed.word(187); + row[layout.auxiliaries + 184] = v_184; + row[layout.auxiliaries + 185] = v_185; + row[layout.auxiliaries + 186] = v_186; + switch (v_184) { + case 0ULL: { + const uint64_t v_187 = seed.word(188); + const uint64_t v_188 = seed.word(189); + const uint64_t v_189 = seed.word(190); + row[layout.auxiliaries + 187] = v_187; + row[layout.auxiliaries + 188] = v_188; + row[layout.auxiliaries + 189] = v_189; + switch (v_187) { + case 0ULL: { + const uint64_t v_190 = seed.word(191); + const uint64_t v_191 = seed.word(192); + const uint64_t v_192 = seed.word(193); + row[layout.auxiliaries + 190] = v_190; + row[layout.auxiliaries + 191] = v_191; + row[layout.auxiliaries + 192] = v_192; + switch (v_190) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_28(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 848 : 1552; + const Seed_ixvm_28 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_28(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_28(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_28<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_28<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_28(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 193) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 848 : encoding == 0 ? 1552 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_28); +} + +template struct Seed_ixvm_31 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u32(data + 100); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 104); + case 5: return load_u32(data + 108); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 128); + case 8: return load_u8(data + 129); + case 9: return load_u8(data + 130); + case 10: return load_u8(data + 131); + case 11: return load_u8(data + 132); + case 12: return load_u8(data + 133); + case 13: return load_u8(data + 134); + case 14: return load_u8(data + 135); + case 15: return load_u8(data + 136); + case 16: return load_u8(data + 137); + case 17: return load_u8(data + 138); + case 18: return load_u8(data + 139); + case 19: return load_u8(data + 140); + case 20: return load_u8(data + 141); + case 21: return load_u8(data + 142); + case 22: return load_u8(data + 143); + case 23: return load_u8(data + 144); + case 24: return load_u8(data + 145); + case 25: return load_u8(data + 146); + case 26: return load_u8(data + 147); + case 27: return load_u8(data + 148); + case 28: return load_u8(data + 149); + case 29: return load_u8(data + 150); + case 30: return load_u8(data + 151); + case 31: return load_u8(data + 152); + case 32: return load_u8(data + 153); + case 33: return load_u8(data + 154); + case 34: return load_u8(data + 155); + case 35: return load_u8(data + 156); + case 36: return load_u8(data + 157); + case 37: return load_u8(data + 158); + case 38: return load_u8(data + 159); + case 39: return load_u8(data + 160); + case 40: return load_u8(data + 161); + case 41: return load_u8(data + 162); + case 42: return load_u8(data + 163); + case 43: return load_u8(data + 164); + case 44: return load_u8(data + 165); + case 45: return load_u8(data + 166); + case 46: return load_u8(data + 167); + case 47: return load_u8(data + 168); + case 48: return load_u8(data + 169); + case 49: return load_u8(data + 170); + case 50: return load_u8(data + 171); + case 51: return load_u8(data + 172); + case 52: return load_u8(data + 173); + case 53: return load_u8(data + 174); + case 54: return load_u8(data + 175); + case 55: return load_u8(data + 176); + case 56: return load_u8(data + 177); + case 57: return load_u8(data + 178); + case 58: return load_u8(data + 179); + case 59: return load_u8(data + 180); + case 60: return load_u8(data + 181); + case 61: return load_u8(data + 182); + case 62: return load_u8(data + 183); + case 63: return load_u8(data + 184); + case 64: return load_u8(data + 185); + case 65: return load_u8(data + 186); + case 66: return load_u8(data + 187); + case 67: return load_u8(data + 188); + case 68: return load_u8(data + 189); + case 69: return load_u8(data + 190); + case 70: return load_u8(data + 191); + case 71: return load_u8(data + 192); + case 72: return load_u8(data + 193); + case 73: return load_u8(data + 194); + case 74: return load_u8(data + 195); + case 75: return load_u8(data + 196); + case 76: return load_u8(data + 197); + case 77: return load_u8(data + 198); + case 78: return load_u8(data + 199); + case 79: return load_u8(data + 200); + case 80: return load_u8(data + 201); + case 81: return load_u8(data + 202); + case 82: return load_u8(data + 203); + case 83: return load_u8(data + 204); + case 84: return load_u8(data + 205); + case 85: return load_u8(data + 206); + case 86: return load_u8(data + 207); + case 87: return load_u8(data + 208); + case 88: return load_u8(data + 209); + case 89: return load_u8(data + 210); + case 90: return load_u8(data + 211); + case 91: return load_u8(data + 212); + case 92: return load_u8(data + 213); + case 93: return load_u8(data + 214); + case 94: return load_u8(data + 215); + case 95: return load_u8(data + 216); + case 96: return load_u8(data + 217); + case 97: return load_u8(data + 218); + case 98: return load_u8(data + 219); + case 99: return load_u8(data + 220); + case 100: return load_u8(data + 221); + case 101: return load_u8(data + 222); + case 102: return load_u8(data + 223); + case 103: return load_u8(data + 224); + case 104: return load_u8(data + 225); + case 105: return load_u8(data + 226); + case 106: return load_u8(data + 227); + case 107: return load_u8(data + 228); + case 108: return load_u8(data + 229); + case 109: return load_u8(data + 230); + case 110: return load_u8(data + 231); + case 111: return load_u8(data + 232); + case 112: return load_u8(data + 233); + case 113: return load_u8(data + 234); + case 114: return load_u8(data + 235); + case 115: return load_u8(data + 236); + case 116: return load_u8(data + 237); + case 117: return load_u8(data + 238); + case 118: return load_u8(data + 239); + case 119: return load_u8(data + 240); + case 120: return load_u8(data + 241); + case 121: return load_u8(data + 242); + case 122: return load_u8(data + 243); + case 123: return load_u8(data + 244); + case 124: return load_u8(data + 245); + case 125: return load_u8(data + 246); + case 126: return load_u8(data + 247); + case 127: return load_u8(data + 248); + case 128: return load_u8(data + 249); + case 129: return load_u8(data + 250); + case 130: return load_u8(data + 251); + case 131: return load_u8(data + 252); + case 132: return load_u8(data + 253); + case 133: return load_u8(data + 254); + case 134: return load_u8(data + 255); + case 135: return load_u8(data + 256); + case 136: return load_u8(data + 257); + case 137: return load_u8(data + 258); + case 138: return load_u8(data + 259); + case 139: return load_u8(data + 260); + case 140: return load_u8(data + 261); + case 141: return load_u8(data + 262); + case 142: return load_u8(data + 263); + case 143: return load_u8(data + 264); + case 144: return load_u8(data + 265); + case 145: return load_u32(data + 112); + case 146: return load_u32(data + 116); + case 147: return load_u64(data + 24); + case 148: return load_u64(data + 32); + case 149: return load_u64(data + 40); + case 150: return load_u64(data + 48); + case 151: return load_u64(data + 56); + case 152: return load_u64(data + 64); + case 153: return load_u64(data + 72); + case 154: return load_u64(data + 80); + case 155: return load_u32(data + 120); + case 156: return load_u32(data + 124); + case 157: return load_u64(data + 88); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_31(Seed_ixvm_31 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_8 = 8ULL; + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + const uint64_t v_23 = seed.word(21); + const uint64_t v_24 = seed.word(22); + const uint64_t v_25 = seed.word(23); + const uint64_t v_26 = seed.word(24); + const uint64_t v_27 = seed.word(25); + const uint64_t v_28 = seed.word(26); + const uint64_t v_29 = seed.word(27); + const uint64_t v_30 = seed.word(28); + const uint64_t v_31 = seed.word(29); + const uint64_t v_32 = seed.word(30); + const uint64_t v_33 = seed.word(31); + const uint64_t v_34 = seed.word(32); + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + const uint64_t v_44 = seed.word(42); + const uint64_t v_45 = seed.word(43); + const uint64_t v_46 = seed.word(44); + const uint64_t v_47 = seed.word(45); + const uint64_t v_48 = seed.word(46); + const uint64_t v_49 = seed.word(47); + const uint64_t v_50 = seed.word(48); + const uint64_t v_51 = seed.word(49); + const uint64_t v_52 = seed.word(50); + const uint64_t v_53 = seed.word(51); + const uint64_t v_54 = seed.word(52); + const uint64_t v_55 = seed.word(53); + const uint64_t v_56 = seed.word(54); + const uint64_t v_57 = seed.word(55); + const uint64_t v_58 = seed.word(56); + const uint64_t v_59 = seed.word(57); + const uint64_t v_60 = seed.word(58); + const uint64_t v_61 = seed.word(59); + const uint64_t v_62 = seed.word(60); + const uint64_t v_63 = seed.word(61); + const uint64_t v_64 = seed.word(62); + const uint64_t v_65 = seed.word(63); + const uint64_t v_66 = seed.word(64); + const uint64_t v_67 = seed.word(65); + const uint64_t v_68 = seed.word(66); + const uint64_t v_69 = seed.word(67); + const uint64_t v_70 = seed.word(68); + const uint64_t v_71 = seed.word(69); + const uint64_t v_72 = seed.word(70); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + row[layout.auxiliaries + 15] = v_23; + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + row[layout.auxiliaries + 18] = v_26; + row[layout.auxiliaries + 19] = v_27; + row[layout.auxiliaries + 20] = v_28; + row[layout.auxiliaries + 21] = v_29; + row[layout.auxiliaries + 22] = v_30; + row[layout.auxiliaries + 23] = v_31; + row[layout.auxiliaries + 24] = v_32; + row[layout.auxiliaries + 25] = v_33; + row[layout.auxiliaries + 26] = v_34; + row[layout.auxiliaries + 27] = v_35; + row[layout.auxiliaries + 28] = v_36; + row[layout.auxiliaries + 29] = v_37; + row[layout.auxiliaries + 30] = v_38; + row[layout.auxiliaries + 31] = v_39; + row[layout.auxiliaries + 32] = v_40; + row[layout.auxiliaries + 33] = v_41; + row[layout.auxiliaries + 34] = v_42; + row[layout.auxiliaries + 35] = v_43; + row[layout.auxiliaries + 36] = v_44; + row[layout.auxiliaries + 37] = v_45; + row[layout.auxiliaries + 38] = v_46; + row[layout.auxiliaries + 39] = v_47; + row[layout.auxiliaries + 40] = v_48; + row[layout.auxiliaries + 41] = v_49; + row[layout.auxiliaries + 42] = v_50; + row[layout.auxiliaries + 43] = v_51; + row[layout.auxiliaries + 44] = v_52; + row[layout.auxiliaries + 45] = v_53; + row[layout.auxiliaries + 46] = v_54; + row[layout.auxiliaries + 47] = v_55; + row[layout.auxiliaries + 48] = v_56; + row[layout.auxiliaries + 49] = v_57; + row[layout.auxiliaries + 50] = v_58; + row[layout.auxiliaries + 51] = v_59; + row[layout.auxiliaries + 52] = v_60; + row[layout.auxiliaries + 53] = v_61; + row[layout.auxiliaries + 54] = v_62; + row[layout.auxiliaries + 55] = v_63; + row[layout.auxiliaries + 56] = v_64; + row[layout.auxiliaries + 57] = v_65; + row[layout.auxiliaries + 58] = v_66; + row[layout.auxiliaries + 59] = v_67; + row[layout.auxiliaries + 60] = v_68; + row[layout.auxiliaries + 61] = v_69; + row[layout.auxiliaries + 62] = v_70; + row[layout.auxiliaries + 63] = v_71; + row[layout.auxiliaries + 64] = v_72; + switch (v_2) { + case 1023ULL: { + const uint64_t v_73 = seed.word(71); + row[layout.auxiliaries + 65] = v_73; + const uint64_t v_74 = seed.word(72); + const uint64_t v_75 = seed.word(73); + const uint64_t v_76 = seed.word(74); + const uint64_t v_77 = seed.word(75); + const uint64_t v_78 = seed.word(76); + const uint64_t v_79 = seed.word(77); + const uint64_t v_80 = seed.word(78); + const uint64_t v_81 = seed.word(79); + row[layout.auxiliaries + 66] = v_74; + row[layout.auxiliaries + 67] = v_75; + row[layout.auxiliaries + 68] = v_76; + row[layout.auxiliaries + 69] = v_77; + row[layout.auxiliaries + 70] = v_78; + row[layout.auxiliaries + 71] = v_79; + row[layout.auxiliaries + 72] = v_80; + row[layout.auxiliaries + 73] = v_81; + const uint64_t v_82 = seed.word(80); + row[layout.auxiliaries + 74] = v_82; + const uint64_t v_83 = goldilocks_mul(v_73, v_82); + row[layout.auxiliaries + 75] = v_83; + const uint64_t v_117 = seed.word(81); + const uint64_t v_118 = seed.word(82); + const uint64_t v_119 = seed.word(83); + const uint64_t v_120 = seed.word(84); + const uint64_t v_121 = seed.word(85); + const uint64_t v_122 = seed.word(86); + const uint64_t v_123 = seed.word(87); + const uint64_t v_124 = seed.word(88); + const uint64_t v_125 = seed.word(89); + const uint64_t v_126 = seed.word(90); + const uint64_t v_127 = seed.word(91); + const uint64_t v_128 = seed.word(92); + const uint64_t v_129 = seed.word(93); + const uint64_t v_130 = seed.word(94); + const uint64_t v_131 = seed.word(95); + const uint64_t v_132 = seed.word(96); + const uint64_t v_133 = seed.word(97); + const uint64_t v_134 = seed.word(98); + const uint64_t v_135 = seed.word(99); + const uint64_t v_136 = seed.word(100); + const uint64_t v_137 = seed.word(101); + const uint64_t v_138 = seed.word(102); + const uint64_t v_139 = seed.word(103); + const uint64_t v_140 = seed.word(104); + const uint64_t v_141 = seed.word(105); + const uint64_t v_142 = seed.word(106); + const uint64_t v_143 = seed.word(107); + const uint64_t v_144 = seed.word(108); + const uint64_t v_145 = seed.word(109); + const uint64_t v_146 = seed.word(110); + const uint64_t v_147 = seed.word(111); + const uint64_t v_148 = seed.word(112); + row[layout.auxiliaries + 76] = v_117; + row[layout.auxiliaries + 77] = v_118; + row[layout.auxiliaries + 78] = v_119; + row[layout.auxiliaries + 79] = v_120; + row[layout.auxiliaries + 80] = v_121; + row[layout.auxiliaries + 81] = v_122; + row[layout.auxiliaries + 82] = v_123; + row[layout.auxiliaries + 83] = v_124; + row[layout.auxiliaries + 84] = v_125; + row[layout.auxiliaries + 85] = v_126; + row[layout.auxiliaries + 86] = v_127; + row[layout.auxiliaries + 87] = v_128; + row[layout.auxiliaries + 88] = v_129; + row[layout.auxiliaries + 89] = v_130; + row[layout.auxiliaries + 90] = v_131; + row[layout.auxiliaries + 91] = v_132; + row[layout.auxiliaries + 92] = v_133; + row[layout.auxiliaries + 93] = v_134; + row[layout.auxiliaries + 94] = v_135; + row[layout.auxiliaries + 95] = v_136; + row[layout.auxiliaries + 96] = v_137; + row[layout.auxiliaries + 97] = v_138; + row[layout.auxiliaries + 98] = v_139; + row[layout.auxiliaries + 99] = v_140; + row[layout.auxiliaries + 100] = v_141; + row[layout.auxiliaries + 101] = v_142; + row[layout.auxiliaries + 102] = v_143; + row[layout.auxiliaries + 103] = v_144; + row[layout.auxiliaries + 104] = v_145; + row[layout.auxiliaries + 105] = v_146; + row[layout.auxiliaries + 106] = v_147; + row[layout.auxiliaries + 107] = v_148; + const uint64_t v_151 = seed.word(113); + const uint64_t v_152 = seed.word(114); + const uint64_t v_153 = seed.word(115); + const uint64_t v_154 = seed.word(116); + const uint64_t v_155 = seed.word(117); + const uint64_t v_156 = seed.word(118); + const uint64_t v_157 = seed.word(119); + const uint64_t v_158 = seed.word(120); + const uint64_t v_159 = seed.word(121); + const uint64_t v_160 = seed.word(122); + const uint64_t v_161 = seed.word(123); + const uint64_t v_162 = seed.word(124); + const uint64_t v_163 = seed.word(125); + const uint64_t v_164 = seed.word(126); + const uint64_t v_165 = seed.word(127); + const uint64_t v_166 = seed.word(128); + const uint64_t v_167 = seed.word(129); + const uint64_t v_168 = seed.word(130); + const uint64_t v_169 = seed.word(131); + const uint64_t v_170 = seed.word(132); + const uint64_t v_171 = seed.word(133); + const uint64_t v_172 = seed.word(134); + const uint64_t v_173 = seed.word(135); + const uint64_t v_174 = seed.word(136); + const uint64_t v_175 = seed.word(137); + const uint64_t v_176 = seed.word(138); + const uint64_t v_177 = seed.word(139); + const uint64_t v_178 = seed.word(140); + const uint64_t v_179 = seed.word(141); + const uint64_t v_180 = seed.word(142); + const uint64_t v_181 = seed.word(143); + const uint64_t v_182 = seed.word(144); + row[layout.auxiliaries + 108] = v_151; + row[layout.auxiliaries + 109] = v_152; + row[layout.auxiliaries + 110] = v_153; + row[layout.auxiliaries + 111] = v_154; + row[layout.auxiliaries + 112] = v_155; + row[layout.auxiliaries + 113] = v_156; + row[layout.auxiliaries + 114] = v_157; + row[layout.auxiliaries + 115] = v_158; + row[layout.auxiliaries + 116] = v_159; + row[layout.auxiliaries + 117] = v_160; + row[layout.auxiliaries + 118] = v_161; + row[layout.auxiliaries + 119] = v_162; + row[layout.auxiliaries + 120] = v_163; + row[layout.auxiliaries + 121] = v_164; + row[layout.auxiliaries + 122] = v_165; + row[layout.auxiliaries + 123] = v_166; + row[layout.auxiliaries + 124] = v_167; + row[layout.auxiliaries + 125] = v_168; + row[layout.auxiliaries + 126] = v_169; + row[layout.auxiliaries + 127] = v_170; + row[layout.auxiliaries + 128] = v_171; + row[layout.auxiliaries + 129] = v_172; + row[layout.auxiliaries + 130] = v_173; + row[layout.auxiliaries + 131] = v_174; + row[layout.auxiliaries + 132] = v_175; + row[layout.auxiliaries + 133] = v_176; + row[layout.auxiliaries + 134] = v_177; + row[layout.auxiliaries + 135] = v_178; + row[layout.auxiliaries + 136] = v_179; + row[layout.auxiliaries + 137] = v_180; + row[layout.auxiliaries + 138] = v_181; + row[layout.auxiliaries + 139] = v_182; + const uint64_t v_183 = seed.word(145); + row[layout.auxiliaries + 140] = v_183; + const uint64_t v_185 = seed.word(146); + row[layout.auxiliaries + 141] = v_185; + const uint64_t v_186 = seed.word(147); + const uint64_t v_187 = seed.word(148); + const uint64_t v_188 = seed.word(149); + const uint64_t v_189 = seed.word(150); + const uint64_t v_190 = seed.word(151); + const uint64_t v_191 = seed.word(152); + const uint64_t v_192 = seed.word(153); + const uint64_t v_193 = seed.word(154); + row[layout.auxiliaries + 142] = v_186; + row[layout.auxiliaries + 143] = v_187; + row[layout.auxiliaries + 144] = v_188; + row[layout.auxiliaries + 145] = v_189; + row[layout.auxiliaries + 146] = v_190; + row[layout.auxiliaries + 147] = v_191; + row[layout.auxiliaries + 148] = v_192; + row[layout.auxiliaries + 149] = v_193; + const uint64_t v_194 = seed.word(155); + row[layout.auxiliaries + 150] = v_194; + const uint64_t v_195 = seed.word(156); + row[layout.auxiliaries + 151] = v_195; + const uint64_t v_196 = seed.word(157); + row[layout.auxiliaries + 152] = v_196; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 65] = inverse(goldilocks_sub(v_2, 1023ULL)); + const uint64_t v_197 = seed.word(71); + row[layout.auxiliaries + 66] = v_197; + const uint64_t v_199 = seed.word(72); + row[layout.auxiliaries + 67] = v_199; + const uint64_t v_200 = seed.word(73); + const uint64_t v_201 = seed.word(74); + const uint64_t v_202 = seed.word(75); + const uint64_t v_203 = seed.word(76); + const uint64_t v_204 = seed.word(77); + const uint64_t v_205 = seed.word(78); + const uint64_t v_206 = seed.word(79); + const uint64_t v_207 = seed.word(80); + row[layout.auxiliaries + 68] = v_200; + row[layout.auxiliaries + 69] = v_201; + row[layout.auxiliaries + 70] = v_202; + row[layout.auxiliaries + 71] = v_203; + row[layout.auxiliaries + 72] = v_204; + row[layout.auxiliaries + 73] = v_205; + row[layout.auxiliaries + 74] = v_206; + row[layout.auxiliaries + 75] = v_207; + const uint64_t v_208 = seed.word(81); + row[layout.auxiliaries + 76] = v_208; + const uint64_t v_209 = goldilocks_mul(v_208, v_8); + const uint64_t v_210 = goldilocks_mul(v_199, v_209); + row[layout.auxiliaries + 77] = v_210; + const uint64_t v_211 = 63ULL; + const uint64_t v_212 = goldilocks_sub(v_2, v_211); + const uint64_t v_213 = uint64_t(v_212 == 0); + row[layout.auxiliaries + 78] = inverse(v_212); + row[layout.auxiliaries + 79] = v_213; + const uint64_t v_217 = seed.word(82); + const uint64_t v_218 = seed.word(83); + const uint64_t v_219 = seed.word(84); + const uint64_t v_220 = seed.word(85); + const uint64_t v_221 = seed.word(86); + const uint64_t v_222 = seed.word(87); + const uint64_t v_223 = seed.word(88); + const uint64_t v_224 = seed.word(89); + const uint64_t v_225 = seed.word(90); + const uint64_t v_226 = seed.word(91); + const uint64_t v_227 = seed.word(92); + const uint64_t v_228 = seed.word(93); + const uint64_t v_229 = seed.word(94); + const uint64_t v_230 = seed.word(95); + const uint64_t v_231 = seed.word(96); + const uint64_t v_232 = seed.word(97); + const uint64_t v_233 = seed.word(98); + const uint64_t v_234 = seed.word(99); + const uint64_t v_235 = seed.word(100); + const uint64_t v_236 = seed.word(101); + const uint64_t v_237 = seed.word(102); + const uint64_t v_238 = seed.word(103); + const uint64_t v_239 = seed.word(104); + const uint64_t v_240 = seed.word(105); + const uint64_t v_241 = seed.word(106); + const uint64_t v_242 = seed.word(107); + const uint64_t v_243 = seed.word(108); + const uint64_t v_244 = seed.word(109); + const uint64_t v_245 = seed.word(110); + const uint64_t v_246 = seed.word(111); + const uint64_t v_247 = seed.word(112); + const uint64_t v_248 = seed.word(113); + row[layout.auxiliaries + 80] = v_217; + row[layout.auxiliaries + 81] = v_218; + row[layout.auxiliaries + 82] = v_219; + row[layout.auxiliaries + 83] = v_220; + row[layout.auxiliaries + 84] = v_221; + row[layout.auxiliaries + 85] = v_222; + row[layout.auxiliaries + 86] = v_223; + row[layout.auxiliaries + 87] = v_224; + row[layout.auxiliaries + 88] = v_225; + row[layout.auxiliaries + 89] = v_226; + row[layout.auxiliaries + 90] = v_227; + row[layout.auxiliaries + 91] = v_228; + row[layout.auxiliaries + 92] = v_229; + row[layout.auxiliaries + 93] = v_230; + row[layout.auxiliaries + 94] = v_231; + row[layout.auxiliaries + 95] = v_232; + row[layout.auxiliaries + 96] = v_233; + row[layout.auxiliaries + 97] = v_234; + row[layout.auxiliaries + 98] = v_235; + row[layout.auxiliaries + 99] = v_236; + row[layout.auxiliaries + 100] = v_237; + row[layout.auxiliaries + 101] = v_238; + row[layout.auxiliaries + 102] = v_239; + row[layout.auxiliaries + 103] = v_240; + row[layout.auxiliaries + 104] = v_241; + row[layout.auxiliaries + 105] = v_242; + row[layout.auxiliaries + 106] = v_243; + row[layout.auxiliaries + 107] = v_244; + row[layout.auxiliaries + 108] = v_245; + row[layout.auxiliaries + 109] = v_246; + row[layout.auxiliaries + 110] = v_247; + row[layout.auxiliaries + 111] = v_248; + const uint64_t v_266 = seed.word(114); + const uint64_t v_267 = seed.word(115); + const uint64_t v_268 = seed.word(116); + const uint64_t v_269 = seed.word(117); + const uint64_t v_270 = seed.word(118); + const uint64_t v_271 = seed.word(119); + const uint64_t v_272 = seed.word(120); + const uint64_t v_273 = seed.word(121); + const uint64_t v_274 = seed.word(122); + const uint64_t v_275 = seed.word(123); + const uint64_t v_276 = seed.word(124); + const uint64_t v_277 = seed.word(125); + const uint64_t v_278 = seed.word(126); + const uint64_t v_279 = seed.word(127); + const uint64_t v_280 = seed.word(128); + const uint64_t v_281 = seed.word(129); + const uint64_t v_282 = seed.word(130); + const uint64_t v_283 = seed.word(131); + const uint64_t v_284 = seed.word(132); + const uint64_t v_285 = seed.word(133); + const uint64_t v_286 = seed.word(134); + const uint64_t v_287 = seed.word(135); + const uint64_t v_288 = seed.word(136); + const uint64_t v_289 = seed.word(137); + const uint64_t v_290 = seed.word(138); + const uint64_t v_291 = seed.word(139); + const uint64_t v_292 = seed.word(140); + const uint64_t v_293 = seed.word(141); + const uint64_t v_294 = seed.word(142); + const uint64_t v_295 = seed.word(143); + const uint64_t v_296 = seed.word(144); + const uint64_t v_297 = seed.word(145); + row[layout.auxiliaries + 112] = v_266; + row[layout.auxiliaries + 113] = v_267; + row[layout.auxiliaries + 114] = v_268; + row[layout.auxiliaries + 115] = v_269; + row[layout.auxiliaries + 116] = v_270; + row[layout.auxiliaries + 117] = v_271; + row[layout.auxiliaries + 118] = v_272; + row[layout.auxiliaries + 119] = v_273; + row[layout.auxiliaries + 120] = v_274; + row[layout.auxiliaries + 121] = v_275; + row[layout.auxiliaries + 122] = v_276; + row[layout.auxiliaries + 123] = v_277; + row[layout.auxiliaries + 124] = v_278; + row[layout.auxiliaries + 125] = v_279; + row[layout.auxiliaries + 126] = v_280; + row[layout.auxiliaries + 127] = v_281; + row[layout.auxiliaries + 128] = v_282; + row[layout.auxiliaries + 129] = v_283; + row[layout.auxiliaries + 130] = v_284; + row[layout.auxiliaries + 131] = v_285; + row[layout.auxiliaries + 132] = v_286; + row[layout.auxiliaries + 133] = v_287; + row[layout.auxiliaries + 134] = v_288; + row[layout.auxiliaries + 135] = v_289; + row[layout.auxiliaries + 136] = v_290; + row[layout.auxiliaries + 137] = v_291; + row[layout.auxiliaries + 138] = v_292; + row[layout.auxiliaries + 139] = v_293; + row[layout.auxiliaries + 140] = v_294; + row[layout.auxiliaries + 141] = v_295; + row[layout.auxiliaries + 142] = v_296; + row[layout.auxiliaries + 143] = v_297; + const uint64_t v_299 = seed.word(146); + row[layout.auxiliaries + 144] = v_299; + const uint64_t v_301 = seed.word(147); + row[layout.auxiliaries + 145] = v_301; + const uint64_t v_302 = seed.word(148); + row[layout.auxiliaries + 146] = v_302; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_31(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 272 : 1264; + const Seed_ixvm_31 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_31(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_31(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_31<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_31<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_31(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 153) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 272 : encoding == 0 ? 1264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_31); +} + +__device__ __constant__ uint64_t inverse_35_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_35 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_35(Seed_ixvm_35 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_35_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_35(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_ixvm_35 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_35(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_35(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_35<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_35<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_35(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_35); +} + +template struct Seed_ixvm_43 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_43(Seed_ixvm_43 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + switch (v_0) { + default: { + uint64_t v_7; + switch (v_0) { + case 0ULL: { + const uint64_t v_3 = 0ULL; + row[layout.selectors + 0] = 1; + v_7 = v_3; + goto continuation_0; + } + case 1ULL: { + const uint64_t v_4 = 1ULL; + row[layout.selectors + 1] = 1; + v_7 = v_4; + goto continuation_0; + } + case 2ULL: { + const uint64_t v_5 = 2ULL; + row[layout.selectors + 2] = 1; + v_7 = v_5; + goto continuation_0; + } + case 3ULL: { + const uint64_t v_6 = 3ULL; + row[layout.selectors + 3] = 1; + v_7 = v_6; + goto continuation_0; + } + default: { + return 2; + } + } + continuation_0:; + row[layout.auxiliaries + 1] = v_7; + const uint64_t v_9 = seed.word(4); + row[layout.auxiliaries + 2] = v_9; + row[layout.selectors + 4] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_43(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 40; + const Seed_ixvm_43 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_43(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_43(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_43<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_43<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_43(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_43); +} + +template struct Seed_ixvm_79 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u8(data + 28); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_79(Seed_ixvm_79 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_79(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 40; + const Seed_ixvm_79 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_79(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_79(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_79<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_79<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_79(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_79); +} + +__device__ __constant__ uint64_t inverse_80_0[] = {0ULL}; +template struct Seed_ixvm_80 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 104); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 100); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + case 8: return load_u64(data + 40); + case 9: return load_u64(data + 48); + case 10: return load_u64(data + 56); + case 11: return load_u64(data + 64); + case 12: return load_u64(data + 72); + case 13: return load_u64(data + 80); + case 14: return load_u64(data + 88); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_80(Seed_ixvm_80 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_80_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_3 = seed.word(3); + const uint64_t v_4 = seed.word(4); + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + switch (v_3) { + case 0ULL: { + const uint64_t v_8 = seed.word(6); + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + row[layout.auxiliaries + 5] = v_8; + row[layout.auxiliaries + 6] = v_9; + row[layout.auxiliaries + 7] = v_10; + row[layout.auxiliaries + 8] = v_11; + row[layout.auxiliaries + 9] = v_12; + row[layout.auxiliaries + 10] = v_13; + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_80(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 112 : 120; + const Seed_ixvm_80 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_80(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_80(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_80<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_80<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_80(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 14) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 120 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_80); +} + +__device__ __constant__ uint64_t inverse_83_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_83_2[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_83 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 72); + case 2: return load_u8(data + 80); + case 3: return load_u8(data + 81); + case 4: return load_u32(data + 76); + case 5: return load_u8(data + 82); + case 6: return load_u64(data + 8); + case 7: return load_u64(data + 16); + case 8: return load_u64(data + 24); + case 9: return load_u64(data + 32); + case 10: return load_u64(data + 40); + case 11: return load_u64(data + 48); + case 12: return load_u64(data + 56); + case 13: return load_u64(data + 64); + case 14: return load_u8(data + 83); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_83(Seed_ixvm_83 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + const uint64_t v_4 = ((v_2 >> 0) & 1ULL); + const uint64_t v_5 = ((v_2 >> 1) & 1ULL); + const uint64_t v_6 = ((v_2 >> 2) & 1ULL); + const uint64_t v_7 = ((v_2 >> 3) & 1ULL); + const uint64_t v_8 = ((v_2 >> 4) & 1ULL); + const uint64_t v_9 = ((v_2 >> 5) & 1ULL); + const uint64_t v_10 = ((v_2 >> 6) & 1ULL); + const uint64_t v_11 = ((v_2 >> 7) & 1ULL); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + const uint64_t v_12 = 2ULL; + const uint64_t v_14 = 4ULL; + const uint64_t v_21 = goldilocks_mul(v_12, v_5); + const uint64_t v_22 = goldilocks_mul(v_14, v_6); + const uint64_t v_23 = goldilocks_add(v_21, v_22); + const uint64_t v_24 = goldilocks_add(v_4, v_23); + switch (v_7) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_7 <= 0ULL ? inverse_83_0[v_7] : inverse(goldilocks_sub(v_7, 0ULL))); + const uint64_t v_26 = 1ULL; + const uint64_t v_27 = goldilocks_add(v_24, v_26); + const uint64_t v_28 = seed.word(5); + const uint64_t v_29 = seed.word(6); + const uint64_t v_30 = seed.word(7); + const uint64_t v_31 = seed.word(8); + const uint64_t v_32 = seed.word(9); + const uint64_t v_33 = seed.word(10); + const uint64_t v_34 = seed.word(11); + const uint64_t v_35 = seed.word(12); + const uint64_t v_36 = seed.word(13); + row[layout.auxiliaries + 13] = v_28; + row[layout.auxiliaries + 14] = v_29; + row[layout.auxiliaries + 15] = v_30; + row[layout.auxiliaries + 16] = v_31; + row[layout.auxiliaries + 17] = v_32; + row[layout.auxiliaries + 18] = v_33; + row[layout.auxiliaries + 19] = v_34; + row[layout.auxiliaries + 20] = v_35; + row[layout.auxiliaries + 21] = v_36; + const uint64_t v_37 = seed.word(14); + row[layout.auxiliaries + 22] = v_37; + switch (v_27) { + case 1ULL: { + const uint64_t v_38 = 8ULL; + if (v_28 > 255 || v_38 > 255) return 1; + const uint64_t v_39 = uint64_t(v_28 < v_38); + row[layout.auxiliaries + 23] = v_39; + row[layout.selectors + 1] = 1; + goto continuation_1; + } + default: { + row[layout.auxiliaries + 23] = (v_27 <= 1ULL ? inverse_83_2[v_27] : inverse(goldilocks_sub(v_27, 1ULL))); + row[layout.selectors + 2] = 1; + goto continuation_1; + } + } + continuation_1:; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_83(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 88 : 120; + const Seed_ixvm_83 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_83(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_83(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_83<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_83<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_83(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 24) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 120 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_83); +} + +template struct Seed_ixvm_85 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 168); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u8(data + 180); + case 12: return load_u64(data + 80); + case 13: return load_u32(data + 172); + case 14: return load_u32(data + 176); + case 15: return load_u64(data + 88); + case 16: return load_u64(data + 96); + case 17: return load_u64(data + 104); + case 18: return load_u64(data + 112); + case 19: return load_u64(data + 120); + case 20: return load_u64(data + 128); + case 21: return load_u64(data + 136); + case 22: return load_u64(data + 144); + case 23: return load_u64(data + 152); + case 24: return load_u64(data + 160); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_85(Seed_ixvm_85 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 1] = v_10; + switch (v_10) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 2] = v_11; + row[layout.auxiliaries + 3] = v_12; + const uint64_t v_15 = seed.word(14); + row[layout.auxiliaries + 4] = v_15; + const uint64_t v_16 = seed.word(15); + const uint64_t v_17 = seed.word(16); + const uint64_t v_18 = seed.word(17); + const uint64_t v_19 = seed.word(18); + const uint64_t v_20 = seed.word(19); + const uint64_t v_21 = seed.word(20); + const uint64_t v_22 = seed.word(21); + const uint64_t v_23 = seed.word(22); + row[layout.auxiliaries + 5] = v_16; + row[layout.auxiliaries + 6] = v_17; + row[layout.auxiliaries + 7] = v_18; + row[layout.auxiliaries + 8] = v_19; + row[layout.auxiliaries + 9] = v_20; + row[layout.auxiliaries + 10] = v_21; + row[layout.auxiliaries + 11] = v_22; + row[layout.auxiliaries + 12] = v_23; + const uint64_t v_24 = seed.word(23); + const uint64_t v_25 = seed.word(24); + row[layout.auxiliaries + 13] = v_24; + row[layout.auxiliaries + 14] = v_25; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_85(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 184 : 200; + const Seed_ixvm_85 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_85(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_85(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_85<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_85<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_85(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 10 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 184 : encoding == 0 ? 200 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_85); +} + +template struct Seed_ixvm_88 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u8(data + 20); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 21); + case 5: return load_u8(data + 22); + case 6: return load_u8(data + 23); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_88(Seed_ixvm_88 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + const uint64_t v_3 = ((v_1 >> 0) & 1ULL); + const uint64_t v_4 = ((v_1 >> 1) & 1ULL); + const uint64_t v_5 = ((v_1 >> 2) & 1ULL); + const uint64_t v_6 = ((v_1 >> 3) & 1ULL); + const uint64_t v_7 = ((v_1 >> 4) & 1ULL); + const uint64_t v_8 = ((v_1 >> 5) & 1ULL); + const uint64_t v_9 = ((v_1 >> 6) & 1ULL); + const uint64_t v_10 = ((v_1 >> 7) & 1ULL); + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_15 = seed.word(4); + const uint64_t v_16 = seed.word(5); + const uint64_t v_17 = seed.word(6); + row[layout.auxiliaries + 11] = v_15; + row[layout.auxiliaries + 12] = v_16; + row[layout.auxiliaries + 13] = v_17; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_88(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 56; + const Seed_ixvm_88 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_88(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_88(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_88<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_88<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_88(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 14) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_88); +} + +template struct Seed_ixvm_89 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u8(data + 20); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 21); + case 5: return load_u8(data + 22); + case 6: return load_u8(data + 23); + case 7: return load_u8(data + 24); + case 8: return load_u8(data + 25); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_89(Seed_ixvm_89 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + const uint64_t v_3 = ((v_1 >> 0) & 1ULL); + const uint64_t v_4 = ((v_1 >> 1) & 1ULL); + const uint64_t v_5 = ((v_1 >> 2) & 1ULL); + const uint64_t v_6 = ((v_1 >> 3) & 1ULL); + const uint64_t v_7 = ((v_1 >> 4) & 1ULL); + const uint64_t v_8 = ((v_1 >> 5) & 1ULL); + const uint64_t v_9 = ((v_1 >> 6) & 1ULL); + const uint64_t v_10 = ((v_1 >> 7) & 1ULL); + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_13 = seed.word(4); + const uint64_t v_14 = seed.word(5); + const uint64_t v_15 = seed.word(6); + row[layout.auxiliaries + 11] = v_13; + row[layout.auxiliaries + 12] = v_14; + row[layout.auxiliaries + 13] = v_15; + const uint64_t v_16 = seed.word(7); + const uint64_t v_17 = seed.word(8); + row[layout.auxiliaries + 14] = v_16; + row[layout.auxiliaries + 15] = v_17; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_89(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 72; + const Seed_ixvm_89 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_89(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_89(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_89<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_89<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_89(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 72 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_89); +} + +__device__ __constant__ uint64_t inverse_92_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_92 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 248); + case 2: return load_u8(data + 256); + case 3: return load_u8(data + 257); + case 4: return load_u64(data + 8); + case 5: return load_u64(data + 16); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + case 8: return load_u64(data + 40); + case 9: return load_u64(data + 48); + case 10: return load_u64(data + 56); + case 11: return load_u32(data + 252); + case 12: return load_u64(data + 64); + case 13: return load_u64(data + 72); + case 14: return load_u64(data + 80); + case 15: return load_u64(data + 88); + case 16: return load_u64(data + 96); + case 17: return load_u64(data + 104); + case 18: return load_u64(data + 112); + case 19: return load_u64(data + 120); + case 20: return load_u64(data + 128); + case 21: return load_u64(data + 136); + case 22: return load_u64(data + 144); + case 23: return load_u64(data + 152); + case 24: return load_u64(data + 160); + case 25: return load_u64(data + 168); + case 26: return load_u64(data + 176); + case 27: return load_u64(data + 184); + case 28: return load_u64(data + 192); + case 29: return load_u64(data + 200); + case 30: return load_u64(data + 208); + case 31: return load_u64(data + 216); + case 32: return load_u64(data + 224); + case 33: return load_u64(data + 232); + case 34: return load_u64(data + 240); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_92(Seed_ixvm_92 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + switch (v_1) { + case 0ULL: { + const uint64_t v_12 = seed.word(12); + row[layout.auxiliaries + 11] = v_12; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_15 = seed.word(12); + row[layout.auxiliaries + 11] = v_15; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_16 = seed.word(12); + const uint64_t v_17 = seed.word(13); + const uint64_t v_18 = seed.word(14); + const uint64_t v_19 = seed.word(15); + const uint64_t v_20 = seed.word(16); + const uint64_t v_21 = seed.word(17); + const uint64_t v_22 = seed.word(18); + const uint64_t v_23 = seed.word(19); + const uint64_t v_24 = seed.word(20); + row[layout.auxiliaries + 11] = v_16; + row[layout.auxiliaries + 12] = v_17; + row[layout.auxiliaries + 13] = v_18; + row[layout.auxiliaries + 14] = v_19; + row[layout.auxiliaries + 15] = v_20; + row[layout.auxiliaries + 16] = v_21; + row[layout.auxiliaries + 17] = v_22; + row[layout.auxiliaries + 18] = v_23; + row[layout.auxiliaries + 19] = v_24; + const uint64_t v_25 = seed.word(21); + const uint64_t v_26 = seed.word(22); + row[layout.auxiliaries + 20] = v_25; + row[layout.auxiliaries + 21] = v_26; + const uint64_t v_29 = seed.word(23); + row[layout.auxiliaries + 22] = v_29; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_30 = seed.word(12); + const uint64_t v_31 = seed.word(13); + const uint64_t v_32 = seed.word(14); + const uint64_t v_33 = seed.word(15); + const uint64_t v_34 = seed.word(16); + const uint64_t v_35 = seed.word(17); + const uint64_t v_36 = seed.word(18); + const uint64_t v_37 = seed.word(19); + const uint64_t v_38 = seed.word(20); + row[layout.auxiliaries + 11] = v_30; + row[layout.auxiliaries + 12] = v_31; + row[layout.auxiliaries + 13] = v_32; + row[layout.auxiliaries + 14] = v_33; + row[layout.auxiliaries + 15] = v_34; + row[layout.auxiliaries + 16] = v_35; + row[layout.auxiliaries + 17] = v_36; + row[layout.auxiliaries + 18] = v_37; + row[layout.auxiliaries + 19] = v_38; + const uint64_t v_39 = seed.word(21); + const uint64_t v_40 = seed.word(22); + row[layout.auxiliaries + 20] = v_39; + row[layout.auxiliaries + 21] = v_40; + const uint64_t v_43 = seed.word(23); + row[layout.auxiliaries + 22] = v_43; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_44 = seed.word(12); + const uint64_t v_45 = seed.word(13); + const uint64_t v_46 = seed.word(14); + const uint64_t v_47 = seed.word(15); + const uint64_t v_48 = seed.word(16); + const uint64_t v_49 = seed.word(17); + const uint64_t v_50 = seed.word(18); + const uint64_t v_51 = seed.word(19); + const uint64_t v_52 = seed.word(20); + row[layout.auxiliaries + 11] = v_44; + row[layout.auxiliaries + 12] = v_45; + row[layout.auxiliaries + 13] = v_46; + row[layout.auxiliaries + 14] = v_47; + row[layout.auxiliaries + 15] = v_48; + row[layout.auxiliaries + 16] = v_49; + row[layout.auxiliaries + 17] = v_50; + row[layout.auxiliaries + 18] = v_51; + row[layout.auxiliaries + 19] = v_52; + const uint64_t v_53 = seed.word(21); + const uint64_t v_54 = seed.word(22); + row[layout.auxiliaries + 20] = v_53; + row[layout.auxiliaries + 21] = v_54; + const uint64_t v_56 = seed.word(23); + row[layout.auxiliaries + 22] = v_56; + row[layout.selectors + 4] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_59 = seed.word(12); + row[layout.auxiliaries + 11] = v_59; + row[layout.selectors + 5] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_62 = seed.word(12); + row[layout.auxiliaries + 11] = v_62; + row[layout.selectors + 6] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_63 = seed.word(12); + row[layout.auxiliaries + 11] = v_63; + const uint64_t v_65 = seed.word(13); + const uint64_t v_66 = seed.word(14); + row[layout.auxiliaries + 12] = v_65; + row[layout.auxiliaries + 13] = v_66; + const uint64_t v_67 = seed.word(15); + const uint64_t v_68 = seed.word(16); + const uint64_t v_69 = seed.word(17); + const uint64_t v_70 = seed.word(18); + const uint64_t v_71 = seed.word(19); + const uint64_t v_72 = seed.word(20); + const uint64_t v_73 = seed.word(21); + const uint64_t v_74 = seed.word(22); + const uint64_t v_75 = seed.word(23); + const uint64_t v_76 = seed.word(24); + const uint64_t v_77 = seed.word(25); + const uint64_t v_78 = seed.word(26); + const uint64_t v_79 = seed.word(27); + const uint64_t v_80 = seed.word(28); + const uint64_t v_81 = seed.word(29); + const uint64_t v_82 = seed.word(30); + const uint64_t v_83 = seed.word(31); + const uint64_t v_84 = seed.word(32); + row[layout.auxiliaries + 14] = v_67; + row[layout.auxiliaries + 15] = v_68; + row[layout.auxiliaries + 16] = v_69; + row[layout.auxiliaries + 17] = v_70; + row[layout.auxiliaries + 18] = v_71; + row[layout.auxiliaries + 19] = v_72; + row[layout.auxiliaries + 20] = v_73; + row[layout.auxiliaries + 21] = v_74; + row[layout.auxiliaries + 22] = v_75; + row[layout.auxiliaries + 23] = v_76; + row[layout.auxiliaries + 24] = v_77; + row[layout.auxiliaries + 25] = v_78; + row[layout.auxiliaries + 26] = v_79; + row[layout.auxiliaries + 27] = v_80; + row[layout.auxiliaries + 28] = v_81; + row[layout.auxiliaries + 29] = v_82; + row[layout.auxiliaries + 30] = v_83; + row[layout.auxiliaries + 31] = v_84; + switch (v_67) { + case 7ULL: { + const uint64_t v_87 = seed.word(33); + const uint64_t v_88 = seed.word(34); + row[layout.auxiliaries + 32] = v_87; + row[layout.auxiliaries + 33] = v_88; + row[layout.selectors + 7] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 32] = (v_67 <= 7ULL ? inverse_92_0[v_67] : inverse(goldilocks_sub(v_67, 7ULL))); + const uint64_t v_89 = seed.word(33); + const uint64_t v_90 = seed.word(34); + row[layout.auxiliaries + 33] = v_89; + row[layout.auxiliaries + 34] = v_90; + row[layout.selectors + 8] = 1; + return 0; + } + } + } + case 8ULL: { + const uint64_t v_91 = seed.word(12); + row[layout.auxiliaries + 11] = v_91; + const uint64_t v_93 = seed.word(13); + const uint64_t v_94 = seed.word(14); + row[layout.auxiliaries + 12] = v_93; + row[layout.auxiliaries + 13] = v_94; + row[layout.selectors + 9] = 1; + return 0; + } + case 9ULL: { + const uint64_t v_95 = seed.word(12); + row[layout.auxiliaries + 11] = v_95; + const uint64_t v_97 = seed.word(13); + const uint64_t v_98 = seed.word(14); + row[layout.auxiliaries + 12] = v_97; + row[layout.auxiliaries + 13] = v_98; + row[layout.selectors + 10] = 1; + return 0; + } + case 10ULL: { + const uint64_t v_99 = seed.word(12); + const uint64_t v_100 = seed.word(13); + row[layout.auxiliaries + 11] = v_99; + row[layout.auxiliaries + 12] = v_100; + row[layout.selectors + 11] = 1; + return 0; + } + case 11ULL: { + const uint64_t v_103 = seed.word(12); + row[layout.auxiliaries + 11] = v_103; + row[layout.selectors + 12] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_92(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 264 : 280; + const Seed_ixvm_92 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_92(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_92(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_92<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_92<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_92(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 13 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 264 : encoding == 0 ? 280 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_92); +} + +template struct Seed_ixvm_97 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 152); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u8(data + 168); + case 11: return load_u64(data + 72); + case 12: return load_u32(data + 156); + case 13: return load_u64(data + 80); + case 14: return load_u64(data + 88); + case 15: return load_u64(data + 96); + case 16: return load_u64(data + 104); + case 17: return load_u64(data + 112); + case 18: return load_u64(data + 120); + case 19: return load_u64(data + 128); + case 20: return load_u64(data + 136); + case 21: return load_u32(data + 160); + case 22: return load_u64(data + 144); + case 23: return load_u32(data + 164); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_97(Seed_ixvm_97 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 1] = v_9; + switch (v_9) { + case 1ULL: { + const uint64_t v_11 = seed.word(11); + row[layout.auxiliaries + 2] = v_11; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(11); + const uint64_t v_13 = seed.word(12); + row[layout.auxiliaries + 2] = v_12; + row[layout.auxiliaries + 3] = v_13; + const uint64_t v_14 = seed.word(13); + const uint64_t v_15 = seed.word(14); + const uint64_t v_16 = seed.word(15); + const uint64_t v_17 = seed.word(16); + const uint64_t v_18 = seed.word(17); + const uint64_t v_19 = seed.word(18); + const uint64_t v_20 = seed.word(19); + const uint64_t v_21 = seed.word(20); + row[layout.auxiliaries + 4] = v_14; + row[layout.auxiliaries + 5] = v_15; + row[layout.auxiliaries + 6] = v_16; + row[layout.auxiliaries + 7] = v_17; + row[layout.auxiliaries + 8] = v_18; + row[layout.auxiliaries + 9] = v_19; + row[layout.auxiliaries + 10] = v_20; + row[layout.auxiliaries + 11] = v_21; + const uint64_t v_22 = seed.word(21); + const uint64_t v_23 = seed.word(22); + row[layout.auxiliaries + 12] = v_22; + row[layout.auxiliaries + 13] = v_23; + const uint64_t v_25 = seed.word(23); + row[layout.auxiliaries + 14] = v_25; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_97(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 192; + const Seed_ixvm_97 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_97(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_97(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_97<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_97<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_97(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 9 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 192 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_97); +} + +__device__ __constant__ uint64_t inverse_122_0[] = {6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_122 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u8(data + 48); + case 3: return load_u32(data + 36); + case 4: return load_u64(data + 8); + case 5: return load_u64(data + 16); + case 6: return load_u64(data + 24); + case 7: return load_u32(data + 40); + case 8: return load_u32(data + 44); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_122(Seed_ixvm_122 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + switch (v_1) { + case 3ULL: { + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 7] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 5] = (v_1 <= 3ULL ? inverse_122_0[v_1] : inverse(goldilocks_sub(v_1, 3ULL))); + const uint64_t v_9 = seed.word(6); + row[layout.auxiliaries + 6] = v_9; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_122(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 72; + const Seed_ixvm_122 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_122(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_122(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_122<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_122<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_122(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 8) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 72 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_122); +} + +__device__ __constant__ uint64_t inverse_124_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_124_1[] = {0ULL}; +template struct Seed_ixvm_124 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u8(data + 44); + case 4: return load_u8(data + 45); + case 5: return load_u8(data + 46); + case 6: return load_u8(data + 47); + case 7: return load_u8(data + 48); + case 8: return load_u8(data + 49); + case 9: return load_u8(data + 50); + case 10: return load_u8(data + 51); + case 11: return load_u8(data + 52); + case 12: return load_u8(data + 53); + case 13: return load_u32(data + 24); + case 14: return load_u32(data + 28); + case 15: return load_u8(data + 54); + case 16: return load_u8(data + 55); + case 17: return load_u8(data + 56); + case 18: return load_u8(data + 57); + case 19: return load_u8(data + 58); + case 20: return load_u8(data + 59); + case 21: return load_u8(data + 60); + case 22: return load_u8(data + 61); + case 23: return load_u32(data + 32); + case 24: return load_u32(data + 36); + case 25: return load_u8(data + 62); + case 26: return load_u8(data + 63); + case 27: return load_u8(data + 64); + case 28: return load_u8(data + 65); + case 29: return load_u8(data + 66); + case 30: return load_u8(data + 67); + case 31: return load_u8(data + 68); + case 32: return load_u8(data + 69); + case 33: return load_u8(data + 70); + case 34: return load_u8(data + 71); + case 35: return load_u8(data + 72); + case 36: return load_u8(data + 73); + case 37: return load_u8(data + 74); + case 38: return load_u8(data + 75); + case 39: return load_u8(data + 76); + case 40: return load_u8(data + 77); + case 41: return load_u8(data + 78); + case 42: return load_u64(data + 8); + case 43: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_124(Seed_ixvm_124 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + row[layout.auxiliaries + 7] = v_9; + row[layout.auxiliaries + 8] = v_10; + row[layout.auxiliaries + 9] = v_11; + row[layout.auxiliaries + 10] = v_12; + switch (v_3) { + case 1ULL: { + switch (v_2) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 11] = (v_2 <= 0ULL ? inverse_124_0[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_13 = seed.word(14); + row[layout.auxiliaries + 12] = v_13; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + case 0ULL: { + const uint64_t v_14 = seed.word(14); + const uint64_t v_15 = seed.word(15); + const uint64_t v_16 = seed.word(16); + const uint64_t v_17 = seed.word(17); + const uint64_t v_18 = seed.word(18); + const uint64_t v_19 = seed.word(19); + const uint64_t v_20 = seed.word(20); + const uint64_t v_21 = seed.word(21); + const uint64_t v_22 = seed.word(22); + const uint64_t v_23 = seed.word(23); + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.auxiliaries + 14] = v_17; + row[layout.auxiliaries + 15] = v_18; + row[layout.auxiliaries + 16] = v_19; + row[layout.auxiliaries + 17] = v_20; + row[layout.auxiliaries + 18] = v_21; + row[layout.auxiliaries + 19] = v_22; + row[layout.auxiliaries + 20] = v_23; + switch (v_14) { + case 1ULL: { + switch (v_2) { + case 0ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 21] = (v_2 <= 0ULL ? inverse_124_1[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 22] = v_24; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + case 0ULL: { + const uint64_t v_25 = seed.word(24); + const uint64_t v_26 = seed.word(25); + const uint64_t v_27 = seed.word(26); + const uint64_t v_28 = seed.word(27); + const uint64_t v_29 = seed.word(28); + const uint64_t v_30 = seed.word(29); + const uint64_t v_31 = seed.word(30); + const uint64_t v_32 = seed.word(31); + const uint64_t v_33 = seed.word(32); + row[layout.auxiliaries + 21] = v_25; + row[layout.auxiliaries + 22] = v_26; + row[layout.auxiliaries + 23] = v_27; + row[layout.auxiliaries + 24] = v_28; + row[layout.auxiliaries + 25] = v_29; + row[layout.auxiliaries + 26] = v_30; + row[layout.auxiliaries + 27] = v_31; + row[layout.auxiliaries + 28] = v_32; + row[layout.auxiliaries + 29] = v_33; + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + row[layout.auxiliaries + 30] = v_35; + row[layout.auxiliaries + 31] = v_36; + row[layout.auxiliaries + 32] = v_37; + row[layout.auxiliaries + 33] = v_38; + row[layout.auxiliaries + 34] = v_39; + row[layout.auxiliaries + 35] = v_40; + row[layout.auxiliaries + 36] = v_41; + row[layout.auxiliaries + 37] = v_42; + row[layout.auxiliaries + 38] = v_43; + const uint64_t v_45 = seed.word(42); + row[layout.auxiliaries + 39] = v_45; + const uint64_t v_46 = seed.word(43); + row[layout.auxiliaries + 40] = v_46; + row[layout.selectors + 4] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_124(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 80 : 352; + const Seed_ixvm_124 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_124(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_124(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_124<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_124<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_124(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 41) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 80 : encoding == 0 ? 352 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_124); +} + +template struct Seed_ixvm_129 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u8(data + 36); + case 3: return load_u8(data + 37); + case 4: return load_u8(data + 38); + case 5: return load_u8(data + 39); + case 6: return load_u8(data + 40); + case 7: return load_u8(data + 41); + case 8: return load_u8(data + 42); + case 9: return load_u8(data + 43); + case 10: return load_u8(data + 44); + case 11: return load_u32(data + 20); + case 12: return load_u32(data + 24); + case 13: return load_u32(data + 28); + case 14: return load_u64(data + 8); + case 15: return load_u32(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_129(Seed_ixvm_129 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + switch (v_1) { + case 1ULL: { + const uint64_t v_12 = seed.word(12); + row[layout.auxiliaries + 11] = v_12; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + const uint64_t v_16 = seed.word(14); + row[layout.auxiliaries + 13] = v_16; + const uint64_t v_18 = seed.word(15); + row[layout.auxiliaries + 14] = v_18; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_129(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 128; + const Seed_ixvm_129 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_129(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_129(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_129<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_129<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_129(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 128 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_129); +} + +template struct Seed_ixvm_137 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u32(data + 24); + case 4: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_137(Seed_ixvm_137 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 2] = v_5; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_137(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 40; + const Seed_ixvm_137 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_137(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_137(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_137<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_137<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_137(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_137); +} + +__device__ __constant__ uint64_t inverse_139_0[] = {0ULL}; +template struct Seed_ixvm_139 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u64(data + 48); + case 7: return load_u64(data + 56); + case 8: return load_u64(data + 64); + case 9: return load_u32(data + 136); + case 10: return load_u8(data + 168); + case 11: return load_u8(data + 169); + case 12: return load_u8(data + 170); + case 13: return load_u8(data + 171); + case 14: return load_u8(data + 172); + case 15: return load_u8(data + 173); + case 16: return load_u8(data + 174); + case 17: return load_u8(data + 175); + case 18: return load_u8(data + 176); + case 19: return load_u64(data + 72); + case 20: return load_u64(data + 80); + case 21: return load_u64(data + 88); + case 22: return load_u64(data + 96); + case 23: return load_u64(data + 104); + case 24: return load_u64(data + 112); + case 25: return load_u64(data + 120); + case 26: return load_u64(data + 128); + case 27: return load_u32(data + 140); + case 28: return load_u8(data + 177); + case 29: return load_u32(data + 144); + case 30: return load_u32(data + 148); + case 31: return load_u8(data + 178); + case 32: return load_u8(data + 179); + case 33: return load_u8(data + 180); + case 34: return load_u8(data + 181); + case 35: return load_u8(data + 182); + case 36: return load_u8(data + 183); + case 37: return load_u8(data + 184); + case 38: return load_u8(data + 185); + case 39: return load_u8(data + 186); + case 40: return load_u8(data + 187); + case 41: return load_u8(data + 188); + case 42: return load_u8(data + 189); + case 43: return load_u8(data + 190); + case 44: return load_u8(data + 191); + case 45: return load_u8(data + 192); + case 46: return load_u8(data + 193); + case 47: return load_u8(data + 194); + case 48: return load_u8(data + 195); + case 49: return load_u8(data + 196); + case 50: return load_u8(data + 197); + case 51: return load_u8(data + 198); + case 52: return load_u8(data + 199); + case 53: return load_u32(data + 152); + case 54: return load_u32(data + 156); + case 55: return load_u8(data + 200); + case 56: return load_u8(data + 201); + case 57: return load_u8(data + 202); + case 58: return load_u8(data + 203); + case 59: return load_u8(data + 204); + case 60: return load_u8(data + 205); + case 61: return load_u32(data + 160); + case 62: return load_u32(data + 164); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_139(Seed_ixvm_139 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + row[layout.auxiliaries + 1] = v_17; + row[layout.auxiliaries + 2] = v_18; + row[layout.auxiliaries + 3] = v_19; + row[layout.auxiliaries + 4] = v_20; + row[layout.auxiliaries + 5] = v_21; + row[layout.auxiliaries + 6] = v_22; + row[layout.auxiliaries + 7] = v_23; + row[layout.auxiliaries + 8] = v_24; + row[layout.auxiliaries + 9] = v_25; + row[layout.auxiliaries + 10] = v_26; + switch (v_17) { + case 1ULL: { + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 11] = v_27; + switch (v_27) { + case 1ULL: { + const uint64_t v_29 = seed.word(29); + row[layout.auxiliaries + 12] = v_29; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_32 = seed.word(29); + row[layout.auxiliaries + 12] = v_32; + const uint64_t v_33 = seed.word(30); + row[layout.auxiliaries + 13] = v_33; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 0ULL: { + const uint64_t v_34 = seed.word(28); + const uint64_t v_35 = seed.word(29); + const uint64_t v_36 = seed.word(30); + const uint64_t v_37 = seed.word(31); + const uint64_t v_38 = seed.word(32); + const uint64_t v_39 = seed.word(33); + const uint64_t v_40 = seed.word(34); + const uint64_t v_41 = seed.word(35); + const uint64_t v_42 = seed.word(36); + const uint64_t v_43 = seed.word(37); + const uint64_t v_44 = seed.word(38); + const uint64_t v_45 = seed.word(39); + const uint64_t v_46 = seed.word(40); + const uint64_t v_47 = seed.word(41); + const uint64_t v_48 = seed.word(42); + const uint64_t v_49 = seed.word(43); + row[layout.auxiliaries + 11] = v_34; + row[layout.auxiliaries + 12] = v_35; + row[layout.auxiliaries + 13] = v_36; + row[layout.auxiliaries + 14] = v_37; + row[layout.auxiliaries + 15] = v_38; + row[layout.auxiliaries + 16] = v_39; + row[layout.auxiliaries + 17] = v_40; + row[layout.auxiliaries + 18] = v_41; + row[layout.auxiliaries + 19] = v_42; + row[layout.auxiliaries + 20] = v_43; + row[layout.auxiliaries + 21] = v_44; + row[layout.auxiliaries + 22] = v_45; + row[layout.auxiliaries + 23] = v_46; + row[layout.auxiliaries + 24] = v_47; + row[layout.auxiliaries + 25] = v_48; + row[layout.auxiliaries + 26] = v_49; + const uint64_t v_50 = seed.word(44); + const uint64_t v_51 = seed.word(45); + const uint64_t v_52 = seed.word(46); + const uint64_t v_53 = seed.word(47); + const uint64_t v_54 = seed.word(48); + const uint64_t v_55 = seed.word(49); + const uint64_t v_56 = seed.word(50); + const uint64_t v_57 = seed.word(51); + const uint64_t v_58 = seed.word(52); + row[layout.auxiliaries + 27] = v_50; + row[layout.auxiliaries + 28] = v_51; + row[layout.auxiliaries + 29] = v_52; + row[layout.auxiliaries + 30] = v_53; + row[layout.auxiliaries + 31] = v_54; + row[layout.auxiliaries + 32] = v_55; + row[layout.auxiliaries + 33] = v_56; + row[layout.auxiliaries + 34] = v_57; + row[layout.auxiliaries + 35] = v_58; + switch (v_58) { + case 0ULL: { + const uint64_t v_60 = seed.word(53); + row[layout.auxiliaries + 36] = v_60; + const uint64_t v_61 = seed.word(54); + row[layout.auxiliaries + 37] = v_61; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 36] = (v_58 <= 0ULL ? inverse_139_0[v_58] : inverse(goldilocks_sub(v_58, 0ULL))); + const uint64_t v_63 = seed.word(53); + const uint64_t v_64 = seed.word(54); + const uint64_t v_65 = seed.word(55); + const uint64_t v_66 = seed.word(56); + const uint64_t v_67 = seed.word(57); + const uint64_t v_68 = seed.word(58); + const uint64_t v_69 = seed.word(59); + const uint64_t v_70 = seed.word(60); + row[layout.auxiliaries + 37] = v_63; + row[layout.auxiliaries + 38] = v_64; + row[layout.auxiliaries + 39] = v_65; + row[layout.auxiliaries + 40] = v_66; + row[layout.auxiliaries + 41] = v_67; + row[layout.auxiliaries + 42] = v_68; + row[layout.auxiliaries + 43] = v_69; + row[layout.auxiliaries + 44] = v_70; + const uint64_t v_71 = seed.word(61); + row[layout.auxiliaries + 45] = v_71; + const uint64_t v_72 = seed.word(62); + row[layout.auxiliaries + 46] = v_72; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_139(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 208 : 504; + const Seed_ixvm_139 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_139(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_139(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_139<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_139<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_139(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 17 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 47) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 208 : encoding == 0 ? 504 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_139); +} + +__device__ __constant__ uint64_t inverse_227_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_227_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_227_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_227_3[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_227_4[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_227_5[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_227_6[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_227 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 40); + case 4: return load_u32(data + 16); + case 5: return load_u8(data + 41); + case 6: return load_u32(data + 20); + case 7: return load_u8(data + 42); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 43); + case 10: return load_u32(data + 28); + case 11: return load_u8(data + 44); + case 12: return load_u32(data + 32); + case 13: return load_u8(data + 45); + case 14: return load_u32(data + 36); + case 15: return load_u8(data + 46); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_227(Seed_ixvm_227 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 2] = v_2; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_2 <= 1ULL ? inverse_227_0[v_2] : inverse(goldilocks_sub(v_2, 1ULL))); + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 4] = v_4; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 5] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_5 <= 1ULL ? inverse_227_1[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 7] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 8] = v_8; + switch (v_8) { + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_8 <= 1ULL ? inverse_227_2[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_11 = seed.word(9); + row[layout.auxiliaries + 11] = v_11; + switch (v_11) { + case 1ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_11 <= 1ULL ? inverse_227_3[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + const uint64_t v_13 = seed.word(10); + row[layout.auxiliaries + 13] = v_13; + const uint64_t v_14 = seed.word(11); + row[layout.auxiliaries + 14] = v_14; + switch (v_14) { + case 1ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 15] = (v_14 <= 1ULL ? inverse_227_4[v_14] : inverse(goldilocks_sub(v_14, 1ULL))); + const uint64_t v_16 = seed.word(12); + row[layout.auxiliaries + 16] = v_16; + const uint64_t v_17 = seed.word(13); + row[layout.auxiliaries + 17] = v_17; + switch (v_17) { + case 1ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 18] = (v_17 <= 1ULL ? inverse_227_5[v_17] : inverse(goldilocks_sub(v_17, 1ULL))); + const uint64_t v_19 = seed.word(14); + row[layout.auxiliaries + 19] = v_19; + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 20] = v_20; + switch (v_20) { + case 1ULL: { + row[layout.selectors + 6] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 21] = (v_20 <= 1ULL ? inverse_227_6[v_20] : inverse(goldilocks_sub(v_20, 1ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + } + } + } + } + } + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_227(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 128; + const Seed_ixvm_227 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_227(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_227(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_227<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_227<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_227(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 8 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 128 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_227); +} + +template struct Seed_ixvm_263 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 32); + case 3: return load_u8(data + 44); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 36); + case 6: return load_u32(data + 40); + case 7: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_263(Seed_ixvm_263 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 4] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 5] = v_8; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_263(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_263 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_263(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_263(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_263<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_263<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_263(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_263); +} + +template struct Seed_ixvm_349 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u8(data + 56); + case 3: return load_u32(data + 44); + case 4: return load_u32(data + 48); + case 5: return load_u32(data + 52); + case 6: return load_u64(data + 8); + case 7: return load_u64(data + 16); + case 8: return load_u64(data + 24); + case 9: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_349(Seed_ixvm_349 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + case 7ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_10 = seed.word(6); + row[layout.auxiliaries + 5] = v_10; + const uint64_t v_11 = seed.word(7); + row[layout.auxiliaries + 6] = v_11; + const uint64_t v_12 = seed.word(8); + row[layout.auxiliaries + 7] = v_12; + row[layout.selectors + 4] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_13 = seed.word(6); + row[layout.auxiliaries + 5] = v_13; + const uint64_t v_14 = seed.word(7); + row[layout.auxiliaries + 6] = v_14; + const uint64_t v_15 = seed.word(8); + row[layout.auxiliaries + 7] = v_15; + const uint64_t v_16 = seed.word(9); + row[layout.auxiliaries + 8] = v_16; + row[layout.selectors + 5] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_17 = seed.word(6); + row[layout.auxiliaries + 5] = v_17; + const uint64_t v_18 = seed.word(7); + row[layout.auxiliaries + 6] = v_18; + const uint64_t v_19 = seed.word(8); + row[layout.auxiliaries + 7] = v_19; + const uint64_t v_20 = seed.word(9); + row[layout.auxiliaries + 8] = v_20; + row[layout.selectors + 6] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_21 = seed.word(6); + row[layout.auxiliaries + 5] = v_21; + row[layout.selectors + 7] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_22 = seed.word(6); + row[layout.auxiliaries + 5] = v_22; + row[layout.selectors + 8] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_349(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 80; + const Seed_ixvm_349 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_349(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_349(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_349<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_349<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_349(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 80 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_349); +} + +template struct Seed_ixvm_354 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u32(data + 16); + case 4: return load_u8(data + 32); + case 5: return load_u32(data + 20); + case 6: return load_u32(data + 24); + case 7: return load_u32(data + 28); + case 8: return load_u8(data + 33); + case 9: return load_u8(data + 34); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_354(Seed_ixvm_354 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + switch (v_3) { + case 0ULL: { + if (v_4 > 0xffffffffULL || v_1 > 0xffffffffULL) return 3; + const uint32_t op_1 = uint32_t(v_4) - uint32_t(v_1); + const uint64_t v_7 = uint64_t(v_4 < v_1); + row[layout.auxiliaries + 5] = (v_4 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_4 >> 16) & 0xffffULL); + row[layout.auxiliaries + 7] = (uint64_t(op_1) & 0xffffULL); + row[layout.auxiliaries + 8] = ((uint64_t(op_1) >> 16) & 0xffffULL); + row[layout.auxiliaries + 9] = (v_1 & 0xffffULL); + row[layout.auxiliaries + 10] = ((v_1 >> 16) & 0xffffULL); + switch (v_7) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + if (v_4 > 0xffffffffULL || v_2 > 0xffffffffULL) return 3; + const uint32_t op_3 = uint32_t(v_4) - uint32_t(v_2); + const uint64_t v_9 = uint64_t(v_4 < v_2); + row[layout.auxiliaries + 11] = (v_4 & 0xffffULL); + row[layout.auxiliaries + 12] = ((v_4 >> 16) & 0xffffULL); + row[layout.auxiliaries + 13] = (uint64_t(op_3) & 0xffffULL); + row[layout.auxiliaries + 14] = ((uint64_t(op_3) >> 16) & 0xffffULL); + row[layout.auxiliaries + 15] = (v_2 & 0xffffULL); + row[layout.auxiliaries + 16] = ((v_2 >> 16) & 0xffffULL); + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + case 2ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + case 7ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_13 = seed.word(8); + row[layout.auxiliaries + 5] = v_13; + switch (v_13) { + case 1ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_15 = seed.word(9); + row[layout.auxiliaries + 6] = v_15; + row[layout.selectors + 6] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 4ULL: { + const uint64_t v_16 = seed.word(8); + row[layout.auxiliaries + 5] = v_16; + row[layout.selectors + 7] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_17 = seed.word(8); + row[layout.auxiliaries + 5] = v_17; + row[layout.selectors + 8] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_18 = seed.word(8); + row[layout.auxiliaries + 5] = v_18; + row[layout.selectors + 9] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_19 = seed.word(8); + row[layout.auxiliaries + 5] = v_19; + row[layout.selectors + 10] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_354(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 80; + const Seed_ixvm_354 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_354(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_354(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_354<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_354<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_354(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 11 || width < auxiliaries || width - auxiliaries < 17) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 80 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_354); +} + +__device__ __constant__ uint64_t inverse_362_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_362 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u32(data + 24); + case 4: return load_u8(data + 28); + case 5: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_362(Seed_ixvm_362 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_2; + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 2] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_5 <= 1ULL ? inverse_362_0[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(5); + row[layout.auxiliaries + 4] = v_7; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_362(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 48; + const Seed_ixvm_362 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_362(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_362(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_362<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_362<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_362(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_362); +} + +__device__ __constant__ uint64_t inverse_363_0[] = {0ULL}; +template struct Seed_ixvm_363 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u8(data + 48); + case 4: return load_u32(data + 32); + case 5: return load_u32(data + 36); + case 6: return load_u32(data + 40); + case 7: return load_u64(data + 8); + case 8: return load_u32(data + 44); + case 9: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_363(Seed_ixvm_363 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + switch (v_2) { + case 0ULL: { + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 5] = v_6; + switch (v_6) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + case 2ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + case 7ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_12 = seed.word(7); + row[layout.auxiliaries + 5] = v_12; + switch (v_12) { + case 0ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_12 <= 0ULL ? inverse_363_0[v_12] : inverse(goldilocks_sub(v_12, 0ULL))); + const uint64_t v_14 = seed.word(8); + row[layout.auxiliaries + 7] = v_14; + const uint64_t v_15 = seed.word(9); + row[layout.auxiliaries + 8] = v_15; + row[layout.selectors + 6] = 1; + return 0; + } + } + } + case 4ULL: { + const uint64_t v_16 = seed.word(7); + row[layout.auxiliaries + 5] = v_16; + row[layout.selectors + 7] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_17 = seed.word(7); + row[layout.auxiliaries + 5] = v_17; + row[layout.selectors + 8] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_18 = seed.word(7); + row[layout.auxiliaries + 5] = v_18; + row[layout.selectors + 9] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_19 = seed.word(7); + row[layout.auxiliaries + 5] = v_19; + row[layout.selectors + 10] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_363(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 80; + const Seed_ixvm_363 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_363(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_363(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_363<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_363<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_363(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 11 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 80 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_363); +} + +__device__ __constant__ uint64_t inverse_370_0[] = {0ULL}; +template struct Seed_ixvm_370 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u64(data + 8); + case 3: return load_u32(data + 28); + case 4: return load_u32(data + 32); + case 5: return load_u8(data + 36); + case 6: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_370(Seed_ixvm_370 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_370_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 2] = v_3; + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 3] = v_4; + switch (v_4) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 4] = v_5; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_370(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 56; + const Seed_ixvm_370 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_370(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_370(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_370<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_370<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_370(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_370); +} + +template struct Seed_ixvm_371 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u64(data + 8); + case 3: return load_u32(data + 44); + case 4: return load_u8(data + 64); + case 5: return load_u32(data + 48); + case 6: return load_u32(data + 52); + case 7: return load_u32(data + 56); + case 8: return load_u64(data + 16); + case 9: return load_u64(data + 24); + case 10: return load_u64(data + 32); + case 11: return load_u32(data + 60); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_371(Seed_ixvm_371 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + switch (v_3) { + case 0ULL: { + if (v_4 > 0xffffffffULL || v_2 > 0xffffffffULL) return 3; + const uint32_t op_1 = uint32_t(v_4) - uint32_t(v_2); + const uint64_t v_7 = uint64_t(v_4 < v_2); + row[layout.auxiliaries + 5] = (v_4 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_4 >> 16) & 0xffffULL); + row[layout.auxiliaries + 7] = (uint64_t(op_1) & 0xffffULL); + row[layout.auxiliaries + 8] = ((uint64_t(op_1) >> 16) & 0xffffULL); + row[layout.auxiliaries + 9] = (v_2 & 0xffffULL); + row[layout.auxiliaries + 10] = ((v_2 >> 16) & 0xffffULL); + switch (v_7) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 11] = v_10; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 1ULL: { + const uint64_t v_13 = seed.word(8); + row[layout.auxiliaries + 5] = v_13; + row[layout.selectors + 2] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_16 = seed.word(8); + row[layout.auxiliaries + 5] = v_16; + row[layout.selectors + 3] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_18 = seed.word(8); + row[layout.auxiliaries + 5] = v_18; + const uint64_t v_19 = seed.word(9); + row[layout.auxiliaries + 6] = v_19; + const uint64_t v_21 = seed.word(10); + row[layout.auxiliaries + 7] = v_21; + row[layout.selectors + 4] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_23 = seed.word(8); + row[layout.auxiliaries + 5] = v_23; + const uint64_t v_26 = seed.word(9); + row[layout.auxiliaries + 6] = v_26; + const uint64_t v_28 = seed.word(10); + row[layout.auxiliaries + 7] = v_28; + row[layout.selectors + 5] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_30 = seed.word(8); + row[layout.auxiliaries + 5] = v_30; + const uint64_t v_33 = seed.word(9); + row[layout.auxiliaries + 6] = v_33; + const uint64_t v_35 = seed.word(10); + row[layout.auxiliaries + 7] = v_35; + row[layout.selectors + 6] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_37 = seed.word(8); + row[layout.auxiliaries + 5] = v_37; + const uint64_t v_38 = seed.word(9); + row[layout.auxiliaries + 6] = v_38; + const uint64_t v_41 = seed.word(10); + row[layout.auxiliaries + 7] = v_41; + const uint64_t v_42 = seed.word(11); + row[layout.auxiliaries + 8] = v_42; + row[layout.selectors + 7] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_45 = seed.word(8); + row[layout.auxiliaries + 5] = v_45; + row[layout.selectors + 8] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_47 = seed.word(8); + row[layout.auxiliaries + 5] = v_47; + const uint64_t v_48 = seed.word(9); + row[layout.auxiliaries + 6] = v_48; + row[layout.selectors + 9] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_371(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 72 : 96; + const Seed_ixvm_371 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_371(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_371(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_371<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_371<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_371(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 10 || width < auxiliaries || width - auxiliaries < 12) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 72 : encoding == 0 ? 96 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_371); +} + +__device__ __constant__ uint64_t inverse_377_0[] = {0ULL}; +template struct Seed_ixvm_377 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u32(data + 24); + case 4: return load_u8(data + 28); + case 5: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_377(Seed_ixvm_377 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + switch (v_3) { + case 1ULL: { + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 2] = v_5; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = goldilocks_sub(v_0, v_2); + switch (v_6) { + case 0ULL: { + const uint64_t v_8 = seed.word(5); + row[layout.auxiliaries + 2] = v_8; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_6 <= 0ULL ? inverse_377_0[v_6] : inverse(goldilocks_sub(v_6, 0ULL))); + const uint64_t v_12 = seed.word(5); + row[layout.auxiliaries + 3] = v_12; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_377(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 48; + const Seed_ixvm_377 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_377(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_377(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_377<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_377<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_377(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_377); +} + +__device__ __constant__ uint64_t inverse_379_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_379_1[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_379 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u32(data + 32); + case 4: return load_u64(data + 8); + case 5: return load_u32(data + 36); + case 6: return load_u8(data + 40); + case 7: return load_u8(data + 41); + case 8: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_379(Seed_ixvm_379 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + switch (v_3) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_3 <= 0ULL ? inverse_379_0[v_3] : inverse(goldilocks_sub(v_3, 0ULL))); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 3] = v_4; + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 4] = v_5; + switch (v_5) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_7 = seed.word(7); + row[layout.auxiliaries + 5] = v_7; + switch (v_7) { + case 1ULL: { + const uint64_t v_8 = seed.word(8); + row[layout.auxiliaries + 6] = v_8; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_7 <= 1ULL ? inverse_379_1[v_7] : inverse(goldilocks_sub(v_7, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 7] = v_10; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_379(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 72; + const Seed_ixvm_379 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_379(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_379(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_379<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_379<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_379(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 8) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 72 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_379); +} + +template struct Seed_ixvm_380 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 32); + case 3: return load_u64(data + 16); + case 4: return load_u32(data + 36); + case 5: return load_u8(data + 44); + case 6: return load_u32(data + 40); + case 7: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_380(Seed_ixvm_380 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 2] = v_5; + switch (v_5) { + case 1ULL: { + const uint64_t v_6 = seed.word(6); + row[layout.auxiliaries + 3] = v_6; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 4] = v_8; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_11 = seed.word(6); + row[layout.auxiliaries + 3] = v_11; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_380(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_380 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_380(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_380(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_380<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_380<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_380(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_380); +} + +template struct Seed_ixvm_381 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u32(data + 32); + case 4: return load_u8(data + 52); + case 5: return load_u32(data + 36); + case 6: return load_u32(data + 40); + case 7: return load_u32(data + 44); + case 8: return load_u64(data + 8); + case 9: return load_u64(data + 16); + case 10: return load_u32(data + 48); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_381(Seed_ixvm_381 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + switch (v_3) { + case 0ULL: { + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 5] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 5] = v_10; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_13 = seed.word(8); + row[layout.auxiliaries + 5] = v_13; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_15 = seed.word(8); + row[layout.auxiliaries + 5] = v_15; + const uint64_t v_16 = seed.word(9); + row[layout.auxiliaries + 6] = v_16; + const uint64_t v_18 = seed.word(10); + row[layout.auxiliaries + 7] = v_18; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_20 = seed.word(8); + row[layout.auxiliaries + 5] = v_20; + const uint64_t v_23 = seed.word(9); + row[layout.auxiliaries + 6] = v_23; + const uint64_t v_25 = seed.word(10); + row[layout.auxiliaries + 7] = v_25; + row[layout.selectors + 4] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_27 = seed.word(8); + row[layout.auxiliaries + 5] = v_27; + const uint64_t v_30 = seed.word(9); + row[layout.auxiliaries + 6] = v_30; + const uint64_t v_32 = seed.word(10); + row[layout.auxiliaries + 7] = v_32; + row[layout.selectors + 5] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_33 = seed.word(8); + row[layout.auxiliaries + 5] = v_33; + row[layout.selectors + 6] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_36 = seed.word(8); + row[layout.auxiliaries + 5] = v_36; + row[layout.selectors + 7] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_38 = seed.word(8); + row[layout.auxiliaries + 5] = v_38; + const uint64_t v_39 = seed.word(9); + row[layout.auxiliaries + 6] = v_39; + row[layout.selectors + 8] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_381(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 88; + const Seed_ixvm_381 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_381(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_381(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_381<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_381<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_381(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 8) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_381); +} + +__device__ __constant__ uint64_t inverse_393_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_393_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_393_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_393_3[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_393_4[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_393_5[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_393_6[] = {9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_393_7[] = {0ULL}; +template struct Seed_ixvm_393 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 128); + case 2: return load_u64(data + 8); + case 3: return load_u32(data + 132); + case 4: return load_u32(data + 136); + case 5: return load_u32(data + 140); + case 6: return load_u8(data + 236); + case 7: return load_u32(data + 144); + case 8: return load_u32(data + 148); + case 9: return load_u64(data + 16); + case 10: return load_u64(data + 24); + case 11: return load_u32(data + 152); + case 12: return load_u8(data + 237); + case 13: return load_u32(data + 156); + case 14: return load_u64(data + 32); + case 15: return load_u32(data + 160); + case 16: return load_u32(data + 164); + case 17: return load_u32(data + 168); + case 18: return load_u64(data + 40); + case 19: return load_u8(data + 238); + case 20: return load_u64(data + 48); + case 21: return load_u64(data + 56); + case 22: return load_u64(data + 64); + case 23: return load_u32(data + 172); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u64(data + 88); + case 27: return load_u32(data + 176); + case 28: return load_u32(data + 180); + case 29: return load_u8(data + 239); + case 30: return load_u64(data + 96); + case 31: return load_u64(data + 104); + case 32: return load_u64(data + 112); + case 33: return load_u32(data + 184); + case 34: return load_u32(data + 188); + case 35: return load_u32(data + 192); + case 36: return load_u32(data + 196); + case 37: return load_u32(data + 200); + case 38: return load_u32(data + 204); + case 39: return load_u32(data + 208); + case 40: return load_u32(data + 212); + case 41: return load_u32(data + 216); + case 42: return load_u32(data + 220); + case 43: return load_u32(data + 224); + case 44: return load_u32(data + 228); + case 45: return load_u32(data + 232); + case 46: return load_u64(data + 120); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_393(Seed_ixvm_393 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_4; + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 2] = v_5; + switch (v_5) { + case 0ULL: { + const uint64_t v_7 = seed.word(7); + row[layout.auxiliaries + 3] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_5 <= 0ULL ? inverse_393_0[v_5] : inverse(goldilocks_sub(v_5, 0ULL))); + switch (v_1) { + case 0ULL: { + const uint64_t v_8 = seed.word(7); + const uint64_t v_9 = seed.word(8); + const uint64_t v_10 = seed.word(9); + const uint64_t v_11 = seed.word(10); + row[layout.auxiliaries + 4] = v_8; + row[layout.auxiliaries + 5] = v_9; + row[layout.auxiliaries + 6] = v_10; + row[layout.auxiliaries + 7] = v_11; + switch (v_8) { + case 2ULL: { + const uint64_t v_12 = seed.word(11); + row[layout.auxiliaries + 8] = v_12; + const uint64_t v_13 = seed.word(12); + row[layout.auxiliaries + 9] = v_13; + switch (v_13) { + case 0ULL: { + const uint64_t v_15 = seed.word(13); + row[layout.auxiliaries + 10] = v_15; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 10] = (v_13 <= 0ULL ? inverse_393_1[v_13] : inverse(goldilocks_sub(v_13, 0ULL))); + const uint64_t v_16 = seed.word(13); + row[layout.auxiliaries + 11] = v_16; + const uint64_t v_17 = 5ULL; + if (v_16 > 0xffffffffULL || v_17 > 0xffffffffULL) return 3; + const uint32_t op_11 = uint32_t(v_16) - uint32_t(v_17); + const uint64_t v_18 = uint64_t(v_16 < v_17); + row[layout.auxiliaries + 12] = (v_16 & 0xffffULL); + row[layout.auxiliaries + 13] = ((v_16 >> 16) & 0xffffULL); + row[layout.auxiliaries + 14] = (uint64_t(op_11) & 0xffffULL); + row[layout.auxiliaries + 15] = ((uint64_t(op_11) >> 16) & 0xffffULL); + row[layout.auxiliaries + 16] = (v_17 & 0xffffULL); + row[layout.auxiliaries + 17] = ((v_17 >> 16) & 0xffffULL); + switch (v_18) { + case 1ULL: { + const uint64_t v_20 = seed.word(14); + row[layout.auxiliaries + 18] = v_20; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 18] = (v_18 <= 1ULL ? inverse_393_2[v_18] : inverse(goldilocks_sub(v_18, 1ULL))); + const uint64_t v_22 = seed.word(14); + row[layout.auxiliaries + 19] = v_22; + const uint64_t v_24 = seed.word(15); + row[layout.auxiliaries + 20] = v_24; + const uint64_t v_26 = seed.word(16); + row[layout.auxiliaries + 21] = v_26; + const uint64_t v_28 = seed.word(17); + row[layout.auxiliaries + 22] = v_28; + const uint64_t v_30 = seed.word(18); + row[layout.auxiliaries + 23] = v_30; + const uint64_t v_31 = seed.word(19); + const uint64_t v_32 = seed.word(20); + const uint64_t v_33 = seed.word(21); + const uint64_t v_34 = seed.word(22); + row[layout.auxiliaries + 24] = v_31; + row[layout.auxiliaries + 25] = v_32; + row[layout.auxiliaries + 26] = v_33; + row[layout.auxiliaries + 27] = v_34; + switch (v_31) { + case 4ULL: { + const uint64_t v_35 = seed.word(23); + const uint64_t v_36 = seed.word(24); + const uint64_t v_37 = seed.word(25); + const uint64_t v_38 = seed.word(26); + row[layout.auxiliaries + 28] = v_35; + row[layout.auxiliaries + 29] = v_36; + row[layout.auxiliaries + 30] = v_37; + row[layout.auxiliaries + 31] = v_38; + switch (v_35) { + case 4ULL: { + const uint64_t v_40 = seed.word(27); + row[layout.auxiliaries + 32] = v_40; + const uint64_t v_43 = seed.word(28); + row[layout.auxiliaries + 33] = v_43; + const uint64_t v_44 = seed.word(29); + const uint64_t v_45 = seed.word(30); + const uint64_t v_46 = seed.word(31); + const uint64_t v_47 = seed.word(32); + row[layout.auxiliaries + 34] = v_44; + row[layout.auxiliaries + 35] = v_45; + row[layout.auxiliaries + 36] = v_46; + row[layout.auxiliaries + 37] = v_47; + switch (v_44) { + case 4ULL: { + const uint64_t v_49 = seed.word(33); + row[layout.auxiliaries + 38] = v_49; + const uint64_t v_52 = seed.word(34); + row[layout.auxiliaries + 39] = v_52; + const uint64_t v_54 = seed.word(35); + row[layout.auxiliaries + 40] = v_54; + const uint64_t v_56 = seed.word(36); + row[layout.auxiliaries + 41] = v_56; + const uint64_t v_57 = seed.word(37); + row[layout.auxiliaries + 42] = v_57; + const uint64_t v_58 = seed.word(38); + row[layout.auxiliaries + 43] = v_58; + const uint64_t v_59 = seed.word(39); + row[layout.auxiliaries + 44] = v_59; + const uint64_t v_61 = seed.word(40); + row[layout.auxiliaries + 45] = v_61; + const uint64_t v_62 = seed.word(41); + row[layout.auxiliaries + 46] = v_62; + const uint64_t v_63 = seed.word(42); + row[layout.auxiliaries + 47] = v_63; + const uint64_t v_64 = seed.word(43); + row[layout.auxiliaries + 48] = v_64; + const uint64_t v_65 = seed.word(44); + row[layout.auxiliaries + 49] = v_65; + const uint64_t v_67 = seed.word(45); + row[layout.auxiliaries + 50] = v_67; + const uint64_t v_68 = seed.word(46); + row[layout.auxiliaries + 51] = v_68; + row[layout.selectors + 3] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 38] = (v_44 <= 4ULL ? inverse_393_3[v_44] : inverse(goldilocks_sub(v_44, 4ULL))); + const uint64_t v_70 = seed.word(33); + row[layout.auxiliaries + 39] = v_70; + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 32] = (v_35 <= 4ULL ? inverse_393_4[v_35] : inverse(goldilocks_sub(v_35, 4ULL))); + const uint64_t v_72 = seed.word(27); + row[layout.auxiliaries + 33] = v_72; + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 28] = (v_31 <= 4ULL ? inverse_393_5[v_31] : inverse(goldilocks_sub(v_31, 4ULL))); + const uint64_t v_74 = seed.word(23); + row[layout.auxiliaries + 29] = v_74; + row[layout.selectors + 6] = 1; + return 0; + } + } + } + } + } + } + } + default: { + row[layout.auxiliaries + 8] = (v_8 <= 2ULL ? inverse_393_6[v_8] : inverse(goldilocks_sub(v_8, 2ULL))); + const uint64_t v_76 = seed.word(11); + row[layout.auxiliaries + 9] = v_76; + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 4] = (v_1 <= 0ULL ? inverse_393_7[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_78 = seed.word(7); + row[layout.auxiliaries + 5] = v_78; + row[layout.selectors + 8] = 1; + return 0; + } + } + } + } +} +template __global__ void kernel_ixvm_393(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 240 : 376; + const Seed_ixvm_393 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_393(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_393(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_393<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_393<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_393(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 52) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 240 : encoding == 0 ? 376 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_393); +} + +__device__ __constant__ uint64_t inverse_398_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_3[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_4[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_5[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_6[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_7[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_8[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_9[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_10[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_11[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_12[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_13[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_14[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_15[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_16[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_17[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_18[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_19[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_20[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_21[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_398_22[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_398 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 78); + case 4: return load_u32(data + 16); + case 5: return load_u8(data + 79); + case 6: return load_u32(data + 20); + case 7: return load_u8(data + 80); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 81); + case 10: return load_u32(data + 28); + case 11: return load_u8(data + 82); + case 12: return load_u32(data + 32); + case 13: return load_u8(data + 83); + case 14: return load_u32(data + 36); + case 15: return load_u8(data + 84); + case 16: return load_u32(data + 40); + case 17: return load_u8(data + 85); + case 18: return load_u32(data + 44); + case 19: return load_u8(data + 86); + case 20: return load_u32(data + 48); + case 21: return load_u8(data + 87); + case 22: return load_u32(data + 52); + case 23: return load_u8(data + 88); + case 24: return load_u32(data + 56); + case 25: return load_u8(data + 89); + case 26: return load_u32(data + 60); + case 27: return load_u8(data + 90); + case 28: return load_u32(data + 64); + case 29: return load_u8(data + 91); + case 30: return load_u32(data + 68); + case 31: return load_u8(data + 92); + case 32: return load_u32(data + 72); + case 33: return load_u8(data + 93); + case 34: return load_u8(data + 94); + case 35: return load_u8(data + 95); + case 36: return load_u8(data + 96); + case 37: return load_u8(data + 97); + case 38: return load_u16(data + 76); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_398(Seed_ixvm_398 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 2] = v_2; + uint64_t v_50; + switch (v_2) { + case 1ULL: { + const uint64_t v_3 = 1ULL; + row[layout.selectors + 0] = 1; + v_50 = v_3; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 3] = (v_2 <= 1ULL ? inverse_398_1[v_2] : inverse(goldilocks_sub(v_2, 1ULL))); + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 4] = v_4; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 5] = v_5; + switch (v_5) { + case 1ULL: { + const uint64_t v_6 = 1ULL; + row[layout.selectors + 1] = 1; + v_50 = v_6; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 6] = (v_5 <= 1ULL ? inverse_398_2[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 7] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 8] = v_8; + switch (v_8) { + case 1ULL: { + const uint64_t v_9 = 1ULL; + row[layout.selectors + 2] = 1; + v_50 = v_9; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 9] = (v_8 <= 1ULL ? inverse_398_3[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_11 = seed.word(9); + row[layout.auxiliaries + 11] = v_11; + switch (v_11) { + case 1ULL: { + const uint64_t v_12 = 1ULL; + row[layout.selectors + 3] = 1; + v_50 = v_12; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 12] = (v_11 <= 1ULL ? inverse_398_4[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + const uint64_t v_13 = seed.word(10); + row[layout.auxiliaries + 13] = v_13; + const uint64_t v_14 = seed.word(11); + row[layout.auxiliaries + 14] = v_14; + switch (v_14) { + case 1ULL: { + const uint64_t v_15 = 1ULL; + row[layout.selectors + 4] = 1; + v_50 = v_15; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 15] = (v_14 <= 1ULL ? inverse_398_5[v_14] : inverse(goldilocks_sub(v_14, 1ULL))); + const uint64_t v_16 = seed.word(12); + row[layout.auxiliaries + 16] = v_16; + const uint64_t v_17 = seed.word(13); + row[layout.auxiliaries + 17] = v_17; + switch (v_17) { + case 1ULL: { + const uint64_t v_18 = 1ULL; + row[layout.selectors + 5] = 1; + v_50 = v_18; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 18] = (v_17 <= 1ULL ? inverse_398_6[v_17] : inverse(goldilocks_sub(v_17, 1ULL))); + const uint64_t v_19 = seed.word(14); + row[layout.auxiliaries + 19] = v_19; + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 20] = v_20; + switch (v_20) { + case 1ULL: { + const uint64_t v_21 = 1ULL; + row[layout.selectors + 6] = 1; + v_50 = v_21; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 21] = (v_20 <= 1ULL ? inverse_398_7[v_20] : inverse(goldilocks_sub(v_20, 1ULL))); + const uint64_t v_22 = seed.word(16); + row[layout.auxiliaries + 22] = v_22; + const uint64_t v_23 = seed.word(17); + row[layout.auxiliaries + 23] = v_23; + switch (v_23) { + case 1ULL: { + const uint64_t v_24 = 1ULL; + row[layout.selectors + 7] = 1; + v_50 = v_24; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 24] = (v_23 <= 1ULL ? inverse_398_8[v_23] : inverse(goldilocks_sub(v_23, 1ULL))); + const uint64_t v_25 = seed.word(18); + row[layout.auxiliaries + 25] = v_25; + const uint64_t v_26 = seed.word(19); + row[layout.auxiliaries + 26] = v_26; + switch (v_26) { + case 1ULL: { + const uint64_t v_27 = 1ULL; + row[layout.selectors + 8] = 1; + v_50 = v_27; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 27] = (v_26 <= 1ULL ? inverse_398_9[v_26] : inverse(goldilocks_sub(v_26, 1ULL))); + const uint64_t v_28 = seed.word(20); + row[layout.auxiliaries + 28] = v_28; + const uint64_t v_29 = seed.word(21); + row[layout.auxiliaries + 29] = v_29; + switch (v_29) { + case 1ULL: { + const uint64_t v_30 = 1ULL; + row[layout.selectors + 9] = 1; + v_50 = v_30; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 30] = (v_29 <= 1ULL ? inverse_398_10[v_29] : inverse(goldilocks_sub(v_29, 1ULL))); + const uint64_t v_31 = seed.word(22); + row[layout.auxiliaries + 31] = v_31; + const uint64_t v_32 = seed.word(23); + row[layout.auxiliaries + 32] = v_32; + switch (v_32) { + case 1ULL: { + const uint64_t v_33 = 1ULL; + row[layout.selectors + 10] = 1; + v_50 = v_33; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 33] = (v_32 <= 1ULL ? inverse_398_11[v_32] : inverse(goldilocks_sub(v_32, 1ULL))); + const uint64_t v_34 = seed.word(24); + row[layout.auxiliaries + 34] = v_34; + const uint64_t v_35 = seed.word(25); + row[layout.auxiliaries + 35] = v_35; + switch (v_35) { + case 1ULL: { + const uint64_t v_36 = 1ULL; + row[layout.selectors + 11] = 1; + v_50 = v_36; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 36] = (v_35 <= 1ULL ? inverse_398_12[v_35] : inverse(goldilocks_sub(v_35, 1ULL))); + const uint64_t v_37 = seed.word(26); + row[layout.auxiliaries + 37] = v_37; + const uint64_t v_38 = seed.word(27); + row[layout.auxiliaries + 38] = v_38; + switch (v_38) { + case 1ULL: { + const uint64_t v_39 = 1ULL; + row[layout.selectors + 12] = 1; + v_50 = v_39; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 39] = (v_38 <= 1ULL ? inverse_398_13[v_38] : inverse(goldilocks_sub(v_38, 1ULL))); + const uint64_t v_40 = seed.word(28); + row[layout.auxiliaries + 40] = v_40; + const uint64_t v_41 = seed.word(29); + row[layout.auxiliaries + 41] = v_41; + switch (v_41) { + case 1ULL: { + const uint64_t v_42 = 1ULL; + row[layout.selectors + 13] = 1; + v_50 = v_42; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 42] = (v_41 <= 1ULL ? inverse_398_14[v_41] : inverse(goldilocks_sub(v_41, 1ULL))); + const uint64_t v_43 = seed.word(30); + row[layout.auxiliaries + 43] = v_43; + const uint64_t v_44 = seed.word(31); + row[layout.auxiliaries + 44] = v_44; + switch (v_44) { + case 1ULL: { + const uint64_t v_45 = 1ULL; + row[layout.selectors + 14] = 1; + v_50 = v_45; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 45] = (v_44 <= 1ULL ? inverse_398_15[v_44] : inverse(goldilocks_sub(v_44, 1ULL))); + const uint64_t v_46 = seed.word(32); + row[layout.auxiliaries + 46] = v_46; + const uint64_t v_47 = seed.word(33); + row[layout.auxiliaries + 47] = v_47; + switch (v_47) { + case 1ULL: { + const uint64_t v_48 = 1ULL; + row[layout.selectors + 15] = 1; + v_50 = v_48; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 48] = (v_47 <= 1ULL ? inverse_398_16[v_47] : inverse(goldilocks_sub(v_47, 1ULL))); + const uint64_t v_49 = 0ULL; + row[layout.selectors + 16] = 1; + v_50 = v_49; + goto continuation_0; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + continuation_0:; + row[layout.auxiliaries + 49] = v_50; + switch (v_50) { + case 1ULL: { + row[layout.selectors + 17] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 50] = (v_50 <= 1ULL ? inverse_398_17[v_50] : inverse(goldilocks_sub(v_50, 1ULL))); + const uint64_t v_52 = seed.word(34); + row[layout.auxiliaries + 51] = v_52; + switch (v_52) { + case 1ULL: { + row[layout.selectors + 18] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 52] = (v_52 <= 1ULL ? inverse_398_18[v_52] : inverse(goldilocks_sub(v_52, 1ULL))); + const uint64_t v_54 = seed.word(35); + row[layout.auxiliaries + 53] = v_54; + switch (v_54) { + case 1ULL: { + row[layout.selectors + 19] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 54] = (v_54 <= 1ULL ? inverse_398_19[v_54] : inverse(goldilocks_sub(v_54, 1ULL))); + const uint64_t v_56 = seed.word(36); + row[layout.auxiliaries + 55] = v_56; + switch (v_56) { + case 1ULL: { + row[layout.selectors + 20] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 56] = (v_56 <= 1ULL ? inverse_398_20[v_56] : inverse(goldilocks_sub(v_56, 1ULL))); + const uint64_t v_58 = seed.word(37); + row[layout.auxiliaries + 57] = v_58; + switch (v_58) { + case 1ULL: { + row[layout.selectors + 21] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 58] = (v_58 <= 1ULL ? inverse_398_21[v_58] : inverse(goldilocks_sub(v_58, 1ULL))); + const uint64_t v_60 = seed.word(38); + row[layout.auxiliaries + 59] = v_60; + switch (v_60) { + case 1ULL: { + row[layout.selectors + 22] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 60] = (v_60 <= 1ULL ? inverse_398_22[v_60] : inverse(goldilocks_sub(v_60, 1ULL))); + row[layout.selectors + 23] = 1; + return 0; + } + } + } + } + } + } + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_398(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 104 : 312; + const Seed_ixvm_398 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_398(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_398(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_398<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_398<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_398(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 24 || width < auxiliaries || width - auxiliaries < 61) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 104 : encoding == 0 ? 312 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_398); +} + +__device__ __constant__ uint64_t inverse_448_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_448 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u32(data + 16); + case 4: return load_u8(data + 20); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_448(Seed_ixvm_448 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + if (v_0 > 0xffffffffULL || v_1 > 0xffffffffULL) return 3; + const uint32_t op_0 = uint32_t(v_0) - uint32_t(v_1); + const uint64_t v_3 = uint64_t(v_0 < v_1); + row[layout.auxiliaries + 1] = (v_0 & 0xffffULL); + row[layout.auxiliaries + 2] = ((v_0 >> 16) & 0xffffULL); + row[layout.auxiliaries + 3] = (uint64_t(op_0) & 0xffffULL); + row[layout.auxiliaries + 4] = ((uint64_t(op_0) >> 16) & 0xffffULL); + row[layout.auxiliaries + 5] = (v_1 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_1 >> 16) & 0xffffULL); + switch (v_3) { + case 1ULL: { + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 7] = v_4; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 7] = (v_3 <= 1ULL ? inverse_448_0[v_3] : inverse(goldilocks_sub(v_3, 1ULL))); + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 8] = v_5; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_448(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 40; + const Seed_ixvm_448 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_448(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_448(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_448<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_448<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_448(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_448); +} + +__device__ __constant__ uint64_t inverse_454_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_454_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_454_2[] = {0ULL}; +template struct Seed_ixvm_454 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u32(data + 16); + case 4: return load_u8(data + 36); + case 5: return load_u8(data + 37); + case 6: return load_u8(data + 38); + case 7: return load_u32(data + 20); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 39); + case 10: return load_u32(data + 28); + case 11: return load_u32(data + 32); + case 12: return load_u8(data + 40); + case 13: return load_u8(data + 41); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_454(Seed_ixvm_454 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 2] = v_4; + const uint64_t v_5 = goldilocks_mul(v_3, v_4); + row[layout.auxiliaries + 3] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 4] = (v_5 <= 1ULL ? inverse_454_0[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + const uint64_t v_8 = seed.word(7); + const uint64_t v_9 = seed.word(8); + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + row[layout.auxiliaries + 7] = v_9; + const uint64_t v_10 = seed.word(9); + const uint64_t v_11 = seed.word(10); + const uint64_t v_12 = seed.word(11); + row[layout.auxiliaries + 8] = v_10; + row[layout.auxiliaries + 9] = v_11; + row[layout.auxiliaries + 10] = v_12; + const uint64_t v_13 = goldilocks_mul(v_7, v_10); + row[layout.auxiliaries + 11] = v_13; + switch (v_13) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_13 <= 0ULL ? inverse_454_1[v_13] : inverse(goldilocks_sub(v_13, 0ULL))); + const uint64_t v_15 = seed.word(12); + row[layout.auxiliaries + 13] = v_15; + switch (v_15) { + case 0ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 14] = (v_15 <= 0ULL ? inverse_454_2[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); + const uint64_t v_18 = seed.word(13); + row[layout.auxiliaries + 15] = v_18; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_454(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 112; + const Seed_ixvm_454 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_454(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_454(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_454<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_454<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_454(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 112 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_454); +} + +__device__ __constant__ uint64_t inverse_484_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_484 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u32(data + 36); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 40); + case 5: return load_u8(data + 52); + case 6: return load_u32(data + 44); + case 7: return load_u32(data + 48); + case 8: return load_u8(data + 53); + case 9: return load_u64(data + 16); + case 10: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_484(Seed_ixvm_484 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_4; + row[layout.auxiliaries + 2] = v_5; + switch (v_4) { + case 1ULL: { + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 3] = v_6; + const uint64_t v_9 = seed.word(8); + const uint64_t v_10 = seed.word(9); + const uint64_t v_11 = seed.word(10); + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_4 <= 1ULL ? inverse_484_0[v_4] : inverse(goldilocks_sub(v_4, 1ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_484(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 88; + const Seed_ixvm_484 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_484(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_484(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_484<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_484<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_484(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_484); +} + +__device__ __constant__ uint64_t inverse_509_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_509_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_509_3[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_509_5[] = {0ULL}; +template struct Seed_ixvm_509 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 64); + case 2: return load_u32(data + 68); + case 3: return load_u32(data + 72); + case 4: return load_u32(data + 76); + case 5: return load_u8(data + 116); + case 6: return load_u32(data + 80); + case 7: return load_u32(data + 84); + case 8: return load_u64(data + 8); + case 9: return load_u64(data + 16); + case 10: return load_u32(data + 88); + case 11: return load_u64(data + 24); + case 12: return load_u64(data + 32); + case 13: return load_u32(data + 92); + case 14: return load_u32(data + 96); + case 15: return load_u64(data + 40); + case 16: return load_u32(data + 100); + case 17: return load_u32(data + 104); + case 18: return load_u64(data + 48); + case 19: return load_u32(data + 108); + case 20: return load_u32(data + 112); + case 21: return load_u64(data + 56); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_509(Seed_ixvm_509 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_4; + row[layout.auxiliaries + 2] = v_5; + row[layout.auxiliaries + 3] = v_6; + switch (v_4) { + case 1ULL: { + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 4] = v_7; + switch (v_7) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 5] = (v_7 <= 0ULL ? inverse_509_0[v_7] : inverse(goldilocks_sub(v_7, 0ULL))); + const uint64_t v_9 = seed.word(9); + row[layout.auxiliaries + 6] = v_9; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + case 0ULL: { + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + row[layout.auxiliaries + 4] = v_10; + row[layout.auxiliaries + 5] = v_11; + row[layout.auxiliaries + 6] = v_12; + row[layout.auxiliaries + 7] = v_13; + switch (v_10) { + case 5ULL: { + const uint64_t v_14 = seed.word(12); + row[layout.auxiliaries + 8] = v_14; + uint64_t v_17; + switch (v_14) { + case 0ULL: { + row[layout.selectors + 2] = 1; + v_17 = v_11; + goto continuation_1; + } + default: { + row[layout.auxiliaries + 9] = (v_14 <= 0ULL ? inverse_509_2[v_14] : inverse(goldilocks_sub(v_14, 0ULL))); + const uint64_t v_16 = seed.word(13); + row[layout.auxiliaries + 10] = v_16; + row[layout.selectors + 3] = 1; + v_17 = v_16; + goto continuation_1; + } + } + continuation_1:; + row[layout.auxiliaries + 11] = v_17; + const uint64_t v_19 = seed.word(14); + row[layout.auxiliaries + 12] = v_19; + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 13] = v_20; + row[layout.selectors + 4] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 8] = (v_10 <= 5ULL ? inverse_509_3[v_10] : inverse(goldilocks_sub(v_10, 5ULL))); + const uint64_t v_21 = seed.word(12); + row[layout.auxiliaries + 9] = v_21; + uint64_t v_24; + switch (v_21) { + case 0ULL: { + row[layout.selectors + 5] = 1; + v_24 = v_0; + goto continuation_4; + } + default: { + row[layout.auxiliaries + 10] = (v_21 <= 0ULL ? inverse_509_5[v_21] : inverse(goldilocks_sub(v_21, 0ULL))); + const uint64_t v_23 = seed.word(13); + row[layout.auxiliaries + 11] = v_23; + row[layout.selectors + 6] = 1; + v_24 = v_23; + goto continuation_4; + } + } + continuation_4:; + row[layout.auxiliaries + 12] = v_24; + const uint64_t v_25 = seed.word(14); + row[layout.auxiliaries + 13] = v_25; + const uint64_t v_26 = seed.word(15); + const uint64_t v_27 = seed.word(16); + const uint64_t v_28 = seed.word(17); + const uint64_t v_29 = seed.word(18); + row[layout.auxiliaries + 14] = v_26; + row[layout.auxiliaries + 15] = v_27; + row[layout.auxiliaries + 16] = v_28; + row[layout.auxiliaries + 17] = v_29; + switch (v_26) { + case 5ULL: { + const uint64_t v_32 = seed.word(19); + row[layout.auxiliaries + 18] = v_32; + const uint64_t v_33 = seed.word(20); + row[layout.auxiliaries + 19] = v_33; + const uint64_t v_34 = seed.word(21); + row[layout.auxiliaries + 20] = v_34; + row[layout.selectors + 7] = 1; + return 0; + } + default: { + return 2; + } + } + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_509(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 120 : 176; + const Seed_ixvm_509 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_509(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_509(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_509<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_509<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_509(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 8 || width < auxiliaries || width - auxiliaries < 21) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 176 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_509); +} + +__device__ __constant__ uint64_t inverse_533_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_533_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_533_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_533_3[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_533_4[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_533_5[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_533 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 36); + case 4: return load_u32(data + 16); + case 5: return load_u8(data + 37); + case 6: return load_u32(data + 20); + case 7: return load_u8(data + 38); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 39); + case 10: return load_u32(data + 28); + case 11: return load_u8(data + 40); + case 12: return load_u32(data + 32); + case 13: return load_u8(data + 41); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_533(Seed_ixvm_533 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 2] = v_2; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_2 <= 1ULL ? inverse_533_0[v_2] : inverse(goldilocks_sub(v_2, 1ULL))); + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 4] = v_4; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 5] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_5 <= 1ULL ? inverse_533_1[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 7] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 8] = v_8; + switch (v_8) { + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_8 <= 1ULL ? inverse_533_2[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_11 = seed.word(9); + row[layout.auxiliaries + 11] = v_11; + switch (v_11) { + case 1ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_11 <= 1ULL ? inverse_533_3[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + const uint64_t v_13 = seed.word(10); + row[layout.auxiliaries + 13] = v_13; + const uint64_t v_14 = seed.word(11); + row[layout.auxiliaries + 14] = v_14; + switch (v_14) { + case 1ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 15] = (v_14 <= 1ULL ? inverse_533_4[v_14] : inverse(goldilocks_sub(v_14, 1ULL))); + const uint64_t v_16 = seed.word(12); + row[layout.auxiliaries + 16] = v_16; + const uint64_t v_17 = seed.word(13); + row[layout.auxiliaries + 17] = v_17; + switch (v_17) { + case 1ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 18] = (v_17 <= 1ULL ? inverse_533_5[v_17] : inverse(goldilocks_sub(v_17, 1ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + } + } + } + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_533(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 112; + const Seed_ixvm_533 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_533(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_533(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_533<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_533<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_533(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 19) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 112 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_533); +} + +__device__ __constant__ uint64_t inverse_605_0[] = {0ULL}; +template struct Seed_ixvm_605 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 48); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 44); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_605(Seed_ixvm_605 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_605_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + switch (v_2) { + case 5ULL: { + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 6] = v_8; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_605(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 64; + const Seed_ixvm_605 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_605(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_605(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_605<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_605<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_605(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_605); +} + +__device__ __constant__ uint64_t inverse_716_0[] = {0ULL}; +template struct Seed_ixvm_716 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 176); + case 2: return load_u8(data + 177); + case 3: return load_u32(data + 144); + case 4: return load_u8(data + 178); + case 5: return load_u64(data + 8); + case 6: return load_u64(data + 16); + case 7: return load_u64(data + 24); + case 8: return load_u8(data + 179); + case 9: return load_u8(data + 180); + case 10: return load_u64(data + 32); + case 11: return load_u8(data + 181); + case 12: return load_u64(data + 40); + case 13: return load_u32(data + 148); + case 14: return load_u64(data + 48); + case 15: return load_u32(data + 152); + case 16: return load_u64(data + 56); + case 17: return load_u32(data + 156); + case 18: return load_u8(data + 182); + case 19: return load_u64(data + 64); + case 20: return load_u32(data + 160); + case 21: return load_u64(data + 72); + case 22: return load_u64(data + 80); + case 23: return load_u64(data + 88); + case 24: return load_u64(data + 96); + case 25: return load_u64(data + 104); + case 26: return load_u64(data + 112); + case 27: return load_u64(data + 120); + case 28: return load_u64(data + 128); + case 29: return load_u64(data + 136); + case 30: return load_u32(data + 164); + case 31: return load_u32(data + 168); + case 32: return load_u32(data + 172); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_716(Seed_ixvm_716 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[layout.auxiliaries + 1] = v_13; + switch (v_0) { + case 0ULL: { + const uint64_t v_16 = seed.word(15); + row[layout.auxiliaries + 2] = v_16; + const uint64_t v_17 = seed.word(16); + row[layout.auxiliaries + 3] = v_17; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 2] = v_20; + const uint64_t v_21 = seed.word(16); + row[layout.auxiliaries + 3] = v_21; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_24 = seed.word(15); + row[layout.auxiliaries + 2] = v_24; + const uint64_t v_25 = seed.word(16); + row[layout.auxiliaries + 3] = v_25; + const uint64_t v_26 = seed.word(17); + row[layout.auxiliaries + 4] = v_26; + const uint64_t v_27 = seed.word(18); + row[layout.auxiliaries + 5] = v_27; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_30 = seed.word(15); + row[layout.auxiliaries + 2] = v_30; + const uint64_t v_31 = seed.word(16); + row[layout.auxiliaries + 3] = v_31; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_34 = seed.word(15); + row[layout.auxiliaries + 2] = v_34; + const uint64_t v_35 = seed.word(16); + row[layout.auxiliaries + 3] = v_35; + row[layout.selectors + 4] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_38 = seed.word(15); + row[layout.auxiliaries + 2] = v_38; + const uint64_t v_39 = seed.word(16); + row[layout.auxiliaries + 3] = v_39; + row[layout.selectors + 5] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_42 = seed.word(15); + row[layout.auxiliaries + 2] = v_42; + const uint64_t v_43 = seed.word(16); + row[layout.auxiliaries + 3] = v_43; + const uint64_t v_44 = seed.word(17); + row[layout.auxiliaries + 4] = v_44; + const uint64_t v_45 = seed.word(18); + const uint64_t v_46 = seed.word(19); + const uint64_t v_47 = seed.word(20); + const uint64_t v_48 = seed.word(21); + const uint64_t v_49 = seed.word(22); + const uint64_t v_50 = seed.word(23); + const uint64_t v_51 = seed.word(24); + const uint64_t v_52 = seed.word(25); + const uint64_t v_53 = seed.word(26); + const uint64_t v_54 = seed.word(27); + const uint64_t v_55 = seed.word(28); + const uint64_t v_56 = seed.word(29); + row[layout.auxiliaries + 5] = v_45; + row[layout.auxiliaries + 6] = v_46; + row[layout.auxiliaries + 7] = v_47; + row[layout.auxiliaries + 8] = v_48; + row[layout.auxiliaries + 9] = v_49; + row[layout.auxiliaries + 10] = v_50; + row[layout.auxiliaries + 11] = v_51; + row[layout.auxiliaries + 12] = v_52; + row[layout.auxiliaries + 13] = v_53; + row[layout.auxiliaries + 14] = v_54; + row[layout.auxiliaries + 15] = v_55; + row[layout.auxiliaries + 16] = v_56; + switch (v_45) { + case 5ULL: { + const uint64_t v_59 = seed.word(30); + row[layout.auxiliaries + 17] = v_59; + const uint64_t v_60 = seed.word(31); + row[layout.auxiliaries + 18] = v_60; + switch (v_51) { + case 0ULL: { + const uint64_t v_62 = seed.word(32); + row[layout.auxiliaries + 19] = v_62; + row[layout.selectors + 6] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 19] = (v_51 <= 0ULL ? inverse_716_0[v_51] : inverse(goldilocks_sub(v_51, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + return 2; + } + } + } + case 7ULL: { + const uint64_t v_65 = seed.word(15); + row[layout.auxiliaries + 2] = v_65; + const uint64_t v_66 = seed.word(16); + row[layout.auxiliaries + 3] = v_66; + row[layout.selectors + 8] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_716(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 184 : 264; + const Seed_ixvm_716 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_716(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_716(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_716<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_716<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_716(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 13 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 20) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 184 : encoding == 0 ? 264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_716); +} + +__device__ __constant__ uint64_t inverse_724_0[] = {0ULL}; +template struct Seed_ixvm_724 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 32); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 28); + case 6: return load_u8(data + 33); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_724(Seed_ixvm_724 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = goldilocks_sub(v_3, v_1); + switch (v_6) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 4] = (v_6 <= 0ULL ? inverse_724_0[v_6] : inverse(goldilocks_sub(v_6, 0ULL))); + const uint64_t v_8 = seed.word(6); + row[layout.auxiliaries + 5] = v_8; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_724(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 56; + const Seed_ixvm_724 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_724(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_724(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_724<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_724<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_724(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_724); +} + +__device__ __constant__ uint64_t inverse_726_1[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_726 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 28); + case 5: return load_u8(data + 29); + case 6: return load_u32(data + 24); + case 7: return load_u8(data + 30); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_726(Seed_ixvm_726 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + switch (v_3) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 4] = v_6; + switch (v_6) { + case 1ULL: { + row[layout.selectors + 1] = 1; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 5] = (v_6 <= 1ULL ? inverse_726_1[v_6] : inverse(goldilocks_sub(v_6, 1ULL))); + row[layout.selectors + 2] = 1; + goto continuation_0; + } + } + continuation_0:; + row[layout.selectors + 3] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_726(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 64; + const Seed_ixvm_726 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_726(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_726(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_726<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_726<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_726(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_726); +} + +template struct Seed_ixvm_780 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 40); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 28); + case 6: return load_u32(data + 32); + case 7: return load_u32(data + 36); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_780(Seed_ixvm_780 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 4] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 5] = v_8; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_10 = seed.word(6); + row[layout.auxiliaries + 4] = v_10; + const uint64_t v_11 = seed.word(7); + row[layout.auxiliaries + 5] = v_11; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_780(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_780 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_780(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_780(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_780<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_780<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_780(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_780); +} + +template struct Seed_ixvm_786 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 44); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 36); + case 6: return load_u64(data + 24); + case 7: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_786(Seed_ixvm_786 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = seed.word(6); + row[layout.auxiliaries + 4] = v_6; + const uint64_t v_7 = seed.word(7); + row[layout.auxiliaries + 5] = v_7; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_786(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_786 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_786(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_786(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_786<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_786<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_786(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_786); +} + +template struct Seed_ixvm_789 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 40); + case 4: return load_u8(data + 44); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_789(Seed_ixvm_789 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + switch (v_3) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_789(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 56; + const Seed_ixvm_789 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_789(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_789(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_789<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_789<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_789(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_789); +} + +__device__ __constant__ uint64_t inverse_798_0[] = {0ULL}; +template struct Seed_ixvm_798 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 40); + case 4: return load_u8(data + 44); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_798(Seed_ixvm_798 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_798_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_4 = seed.word(3); + row[layout.auxiliaries + 2] = v_4; + const uint64_t v_5 = seed.word(4); + const uint64_t v_6 = seed.word(5); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + switch (v_5) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_798(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 56; + const Seed_ixvm_798 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_798(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_798(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_798<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_798<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_798(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_798); +} + +extern "C" const uint8_t* aiur_trace_ixvm_contract() { + static const uint8_t hash[32] = {105, 148, 4, 31, 222, 124, 60, 173, 125, 34, 225, 72, 91, 85, 247, 185, 3, 166, 203, 236, 62, 61, 0, 53, 211, 122, 15, 138, 124, 182, 105, 169}; + return hash; +} +extern "C" const uint8_t* aiur_trace_ixvm_schema() { + static const uint8_t hash[32] = {249, 165, 130, 187, 57, 136, 86, 3, 242, 185, 236, 196, 53, 22, 168, 152, 177, 142, 184, 161, 42, 193, 33, 194, 238, 56, 151, 75, 156, 59, 193, 129}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/multi_stark.cu b/crates/aiur/cuda/generated/production/multi_stark.cu new file mode 100644 index 000000000..0c9146975 --- /dev/null +++ b/crates/aiur/cuda/generated/production/multi_stark.cu @@ -0,0 +1,6707 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_multi_stark { +using namespace aiur_trace; + +template struct Seed_multi_stark_76 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 528); + case 2: return load_u8(data + 784); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 532); + case 5: return load_u8(data + 785); + case 6: return load_u64(data + 16); + case 7: return load_u32(data + 536); + case 8: return load_u8(data + 786); + case 9: return load_u64(data + 24); + case 10: return load_u32(data + 540); + case 11: return load_u8(data + 787); + case 12: return load_u64(data + 32); + case 13: return load_u32(data + 544); + case 14: return load_u8(data + 788); + case 15: return load_u64(data + 40); + case 16: return load_u32(data + 548); + case 17: return load_u8(data + 789); + case 18: return load_u64(data + 48); + case 19: return load_u32(data + 552); + case 20: return load_u8(data + 790); + case 21: return load_u64(data + 56); + case 22: return load_u32(data + 556); + case 23: return load_u8(data + 791); + case 24: return load_u64(data + 64); + case 25: return load_u32(data + 560); + case 26: return load_u8(data + 792); + case 27: return load_u64(data + 72); + case 28: return load_u32(data + 564); + case 29: return load_u8(data + 793); + case 30: return load_u64(data + 80); + case 31: return load_u32(data + 568); + case 32: return load_u8(data + 794); + case 33: return load_u64(data + 88); + case 34: return load_u32(data + 572); + case 35: return load_u8(data + 795); + case 36: return load_u64(data + 96); + case 37: return load_u32(data + 576); + case 38: return load_u8(data + 796); + case 39: return load_u64(data + 104); + case 40: return load_u32(data + 580); + case 41: return load_u8(data + 797); + case 42: return load_u64(data + 112); + case 43: return load_u32(data + 584); + case 44: return load_u8(data + 798); + case 45: return load_u64(data + 120); + case 46: return load_u32(data + 588); + case 47: return load_u8(data + 799); + case 48: return load_u64(data + 128); + case 49: return load_u32(data + 592); + case 50: return load_u8(data + 800); + case 51: return load_u64(data + 136); + case 52: return load_u32(data + 596); + case 53: return load_u8(data + 801); + case 54: return load_u64(data + 144); + case 55: return load_u32(data + 600); + case 56: return load_u8(data + 802); + case 57: return load_u64(data + 152); + case 58: return load_u32(data + 604); + case 59: return load_u8(data + 803); + case 60: return load_u64(data + 160); + case 61: return load_u32(data + 608); + case 62: return load_u8(data + 804); + case 63: return load_u64(data + 168); + case 64: return load_u32(data + 612); + case 65: return load_u8(data + 805); + case 66: return load_u64(data + 176); + case 67: return load_u32(data + 616); + case 68: return load_u8(data + 806); + case 69: return load_u64(data + 184); + case 70: return load_u32(data + 620); + case 71: return load_u8(data + 807); + case 72: return load_u64(data + 192); + case 73: return load_u32(data + 624); + case 74: return load_u8(data + 808); + case 75: return load_u64(data + 200); + case 76: return load_u32(data + 628); + case 77: return load_u8(data + 809); + case 78: return load_u64(data + 208); + case 79: return load_u32(data + 632); + case 80: return load_u8(data + 810); + case 81: return load_u64(data + 216); + case 82: return load_u32(data + 636); + case 83: return load_u8(data + 811); + case 84: return load_u64(data + 224); + case 85: return load_u32(data + 640); + case 86: return load_u8(data + 812); + case 87: return load_u64(data + 232); + case 88: return load_u32(data + 644); + case 89: return load_u8(data + 813); + case 90: return load_u64(data + 240); + case 91: return load_u32(data + 648); + case 92: return load_u8(data + 814); + case 93: return load_u64(data + 248); + case 94: return load_u32(data + 652); + case 95: return load_u8(data + 815); + case 96: return load_u64(data + 256); + case 97: return load_u32(data + 656); + case 98: return load_u8(data + 816); + case 99: return load_u64(data + 264); + case 100: return load_u32(data + 660); + case 101: return load_u8(data + 817); + case 102: return load_u64(data + 272); + case 103: return load_u32(data + 664); + case 104: return load_u8(data + 818); + case 105: return load_u64(data + 280); + case 106: return load_u32(data + 668); + case 107: return load_u8(data + 819); + case 108: return load_u64(data + 288); + case 109: return load_u32(data + 672); + case 110: return load_u8(data + 820); + case 111: return load_u64(data + 296); + case 112: return load_u32(data + 676); + case 113: return load_u8(data + 821); + case 114: return load_u64(data + 304); + case 115: return load_u32(data + 680); + case 116: return load_u8(data + 822); + case 117: return load_u64(data + 312); + case 118: return load_u32(data + 684); + case 119: return load_u8(data + 823); + case 120: return load_u64(data + 320); + case 121: return load_u32(data + 688); + case 122: return load_u8(data + 824); + case 123: return load_u64(data + 328); + case 124: return load_u32(data + 692); + case 125: return load_u8(data + 825); + case 126: return load_u64(data + 336); + case 127: return load_u32(data + 696); + case 128: return load_u8(data + 826); + case 129: return load_u64(data + 344); + case 130: return load_u32(data + 700); + case 131: return load_u8(data + 827); + case 132: return load_u64(data + 352); + case 133: return load_u32(data + 704); + case 134: return load_u8(data + 828); + case 135: return load_u64(data + 360); + case 136: return load_u32(data + 708); + case 137: return load_u8(data + 829); + case 138: return load_u64(data + 368); + case 139: return load_u32(data + 712); + case 140: return load_u8(data + 830); + case 141: return load_u64(data + 376); + case 142: return load_u32(data + 716); + case 143: return load_u8(data + 831); + case 144: return load_u64(data + 384); + case 145: return load_u32(data + 720); + case 146: return load_u8(data + 832); + case 147: return load_u64(data + 392); + case 148: return load_u32(data + 724); + case 149: return load_u8(data + 833); + case 150: return load_u64(data + 400); + case 151: return load_u32(data + 728); + case 152: return load_u8(data + 834); + case 153: return load_u64(data + 408); + case 154: return load_u32(data + 732); + case 155: return load_u8(data + 835); + case 156: return load_u64(data + 416); + case 157: return load_u32(data + 736); + case 158: return load_u8(data + 836); + case 159: return load_u64(data + 424); + case 160: return load_u32(data + 740); + case 161: return load_u8(data + 837); + case 162: return load_u64(data + 432); + case 163: return load_u32(data + 744); + case 164: return load_u8(data + 838); + case 165: return load_u64(data + 440); + case 166: return load_u32(data + 748); + case 167: return load_u8(data + 839); + case 168: return load_u64(data + 448); + case 169: return load_u32(data + 752); + case 170: return load_u8(data + 840); + case 171: return load_u64(data + 456); + case 172: return load_u32(data + 756); + case 173: return load_u8(data + 841); + case 174: return load_u64(data + 464); + case 175: return load_u32(data + 760); + case 176: return load_u8(data + 842); + case 177: return load_u64(data + 472); + case 178: return load_u32(data + 764); + case 179: return load_u8(data + 843); + case 180: return load_u64(data + 480); + case 181: return load_u32(data + 768); + case 182: return load_u8(data + 844); + case 183: return load_u64(data + 488); + case 184: return load_u32(data + 772); + case 185: return load_u8(data + 845); + case 186: return load_u64(data + 496); + case 187: return load_u32(data + 776); + case 188: return load_u8(data + 846); + case 189: return load_u64(data + 504); + case 190: return load_u32(data + 780); + case 191: return load_u8(data + 847); + case 192: return load_u64(data + 512); + case 193: return load_u64(data + 520); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_76(Seed_multi_stark_76 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + switch (v_4) { + case 0ULL: { + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + switch (v_7) { + case 0ULL: { + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + switch (v_10) { + case 0ULL: { + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + switch (v_13) { + case 0ULL: { + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + switch (v_16) { + case 0ULL: { + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + row[layout.auxiliaries + 19] = v_19; + row[layout.auxiliaries + 20] = v_20; + row[layout.auxiliaries + 21] = v_21; + switch (v_19) { + case 0ULL: { + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 22] = v_22; + row[layout.auxiliaries + 23] = v_23; + row[layout.auxiliaries + 24] = v_24; + switch (v_22) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 25] = v_25; + row[layout.auxiliaries + 26] = v_26; + row[layout.auxiliaries + 27] = v_27; + switch (v_25) { + case 0ULL: { + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 28] = v_28; + row[layout.auxiliaries + 29] = v_29; + row[layout.auxiliaries + 30] = v_30; + switch (v_28) { + case 0ULL: { + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + row[layout.auxiliaries + 31] = v_31; + row[layout.auxiliaries + 32] = v_32; + row[layout.auxiliaries + 33] = v_33; + switch (v_31) { + case 0ULL: { + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 34] = v_34; + row[layout.auxiliaries + 35] = v_35; + row[layout.auxiliaries + 36] = v_36; + switch (v_34) { + case 0ULL: { + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + row[layout.auxiliaries + 37] = v_37; + row[layout.auxiliaries + 38] = v_38; + row[layout.auxiliaries + 39] = v_39; + switch (v_37) { + case 0ULL: { + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + row[layout.auxiliaries + 40] = v_40; + row[layout.auxiliaries + 41] = v_41; + row[layout.auxiliaries + 42] = v_42; + switch (v_40) { + case 0ULL: { + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + row[layout.auxiliaries + 43] = v_43; + row[layout.auxiliaries + 44] = v_44; + row[layout.auxiliaries + 45] = v_45; + switch (v_43) { + case 0ULL: { + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 46] = v_46; + row[layout.auxiliaries + 47] = v_47; + row[layout.auxiliaries + 48] = v_48; + switch (v_46) { + case 0ULL: { + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 49] = v_49; + row[layout.auxiliaries + 50] = v_50; + row[layout.auxiliaries + 51] = v_51; + switch (v_49) { + case 0ULL: { + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + row[layout.auxiliaries + 52] = v_52; + row[layout.auxiliaries + 53] = v_53; + row[layout.auxiliaries + 54] = v_54; + switch (v_52) { + case 0ULL: { + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + const uint64_t v_57 = seed.word(58); + row[layout.auxiliaries + 55] = v_55; + row[layout.auxiliaries + 56] = v_56; + row[layout.auxiliaries + 57] = v_57; + switch (v_55) { + case 0ULL: { + const uint64_t v_58 = seed.word(59); + const uint64_t v_59 = seed.word(60); + const uint64_t v_60 = seed.word(61); + row[layout.auxiliaries + 58] = v_58; + row[layout.auxiliaries + 59] = v_59; + row[layout.auxiliaries + 60] = v_60; + switch (v_58) { + case 0ULL: { + const uint64_t v_61 = seed.word(62); + const uint64_t v_62 = seed.word(63); + const uint64_t v_63 = seed.word(64); + row[layout.auxiliaries + 61] = v_61; + row[layout.auxiliaries + 62] = v_62; + row[layout.auxiliaries + 63] = v_63; + switch (v_61) { + case 0ULL: { + const uint64_t v_64 = seed.word(65); + const uint64_t v_65 = seed.word(66); + const uint64_t v_66 = seed.word(67); + row[layout.auxiliaries + 64] = v_64; + row[layout.auxiliaries + 65] = v_65; + row[layout.auxiliaries + 66] = v_66; + switch (v_64) { + case 0ULL: { + const uint64_t v_67 = seed.word(68); + const uint64_t v_68 = seed.word(69); + const uint64_t v_69 = seed.word(70); + row[layout.auxiliaries + 67] = v_67; + row[layout.auxiliaries + 68] = v_68; + row[layout.auxiliaries + 69] = v_69; + switch (v_67) { + case 0ULL: { + const uint64_t v_70 = seed.word(71); + const uint64_t v_71 = seed.word(72); + const uint64_t v_72 = seed.word(73); + row[layout.auxiliaries + 70] = v_70; + row[layout.auxiliaries + 71] = v_71; + row[layout.auxiliaries + 72] = v_72; + switch (v_70) { + case 0ULL: { + const uint64_t v_73 = seed.word(74); + const uint64_t v_74 = seed.word(75); + const uint64_t v_75 = seed.word(76); + row[layout.auxiliaries + 73] = v_73; + row[layout.auxiliaries + 74] = v_74; + row[layout.auxiliaries + 75] = v_75; + switch (v_73) { + case 0ULL: { + const uint64_t v_76 = seed.word(77); + const uint64_t v_77 = seed.word(78); + const uint64_t v_78 = seed.word(79); + row[layout.auxiliaries + 76] = v_76; + row[layout.auxiliaries + 77] = v_77; + row[layout.auxiliaries + 78] = v_78; + switch (v_76) { + case 0ULL: { + const uint64_t v_79 = seed.word(80); + const uint64_t v_80 = seed.word(81); + const uint64_t v_81 = seed.word(82); + row[layout.auxiliaries + 79] = v_79; + row[layout.auxiliaries + 80] = v_80; + row[layout.auxiliaries + 81] = v_81; + switch (v_79) { + case 0ULL: { + const uint64_t v_82 = seed.word(83); + const uint64_t v_83 = seed.word(84); + const uint64_t v_84 = seed.word(85); + row[layout.auxiliaries + 82] = v_82; + row[layout.auxiliaries + 83] = v_83; + row[layout.auxiliaries + 84] = v_84; + switch (v_82) { + case 0ULL: { + const uint64_t v_85 = seed.word(86); + const uint64_t v_86 = seed.word(87); + const uint64_t v_87 = seed.word(88); + row[layout.auxiliaries + 85] = v_85; + row[layout.auxiliaries + 86] = v_86; + row[layout.auxiliaries + 87] = v_87; + switch (v_85) { + case 0ULL: { + const uint64_t v_88 = seed.word(89); + const uint64_t v_89 = seed.word(90); + const uint64_t v_90 = seed.word(91); + row[layout.auxiliaries + 88] = v_88; + row[layout.auxiliaries + 89] = v_89; + row[layout.auxiliaries + 90] = v_90; + switch (v_88) { + case 0ULL: { + const uint64_t v_91 = seed.word(92); + const uint64_t v_92 = seed.word(93); + const uint64_t v_93 = seed.word(94); + row[layout.auxiliaries + 91] = v_91; + row[layout.auxiliaries + 92] = v_92; + row[layout.auxiliaries + 93] = v_93; + switch (v_91) { + case 0ULL: { + const uint64_t v_94 = seed.word(95); + const uint64_t v_95 = seed.word(96); + const uint64_t v_96 = seed.word(97); + row[layout.auxiliaries + 94] = v_94; + row[layout.auxiliaries + 95] = v_95; + row[layout.auxiliaries + 96] = v_96; + switch (v_94) { + case 0ULL: { + const uint64_t v_97 = seed.word(98); + const uint64_t v_98 = seed.word(99); + const uint64_t v_99 = seed.word(100); + row[layout.auxiliaries + 97] = v_97; + row[layout.auxiliaries + 98] = v_98; + row[layout.auxiliaries + 99] = v_99; + switch (v_97) { + case 0ULL: { + const uint64_t v_100 = seed.word(101); + const uint64_t v_101 = seed.word(102); + const uint64_t v_102 = seed.word(103); + row[layout.auxiliaries + 100] = v_100; + row[layout.auxiliaries + 101] = v_101; + row[layout.auxiliaries + 102] = v_102; + switch (v_100) { + case 0ULL: { + const uint64_t v_103 = seed.word(104); + const uint64_t v_104 = seed.word(105); + const uint64_t v_105 = seed.word(106); + row[layout.auxiliaries + 103] = v_103; + row[layout.auxiliaries + 104] = v_104; + row[layout.auxiliaries + 105] = v_105; + switch (v_103) { + case 0ULL: { + const uint64_t v_106 = seed.word(107); + const uint64_t v_107 = seed.word(108); + const uint64_t v_108 = seed.word(109); + row[layout.auxiliaries + 106] = v_106; + row[layout.auxiliaries + 107] = v_107; + row[layout.auxiliaries + 108] = v_108; + switch (v_106) { + case 0ULL: { + const uint64_t v_109 = seed.word(110); + const uint64_t v_110 = seed.word(111); + const uint64_t v_111 = seed.word(112); + row[layout.auxiliaries + 109] = v_109; + row[layout.auxiliaries + 110] = v_110; + row[layout.auxiliaries + 111] = v_111; + switch (v_109) { + case 0ULL: { + const uint64_t v_112 = seed.word(113); + const uint64_t v_113 = seed.word(114); + const uint64_t v_114 = seed.word(115); + row[layout.auxiliaries + 112] = v_112; + row[layout.auxiliaries + 113] = v_113; + row[layout.auxiliaries + 114] = v_114; + switch (v_112) { + case 0ULL: { + const uint64_t v_115 = seed.word(116); + const uint64_t v_116 = seed.word(117); + const uint64_t v_117 = seed.word(118); + row[layout.auxiliaries + 115] = v_115; + row[layout.auxiliaries + 116] = v_116; + row[layout.auxiliaries + 117] = v_117; + switch (v_115) { + case 0ULL: { + const uint64_t v_118 = seed.word(119); + const uint64_t v_119 = seed.word(120); + const uint64_t v_120 = seed.word(121); + row[layout.auxiliaries + 118] = v_118; + row[layout.auxiliaries + 119] = v_119; + row[layout.auxiliaries + 120] = v_120; + switch (v_118) { + case 0ULL: { + const uint64_t v_121 = seed.word(122); + const uint64_t v_122 = seed.word(123); + const uint64_t v_123 = seed.word(124); + row[layout.auxiliaries + 121] = v_121; + row[layout.auxiliaries + 122] = v_122; + row[layout.auxiliaries + 123] = v_123; + switch (v_121) { + case 0ULL: { + const uint64_t v_124 = seed.word(125); + const uint64_t v_125 = seed.word(126); + const uint64_t v_126 = seed.word(127); + row[layout.auxiliaries + 124] = v_124; + row[layout.auxiliaries + 125] = v_125; + row[layout.auxiliaries + 126] = v_126; + switch (v_124) { + case 0ULL: { + const uint64_t v_127 = seed.word(128); + const uint64_t v_128 = seed.word(129); + const uint64_t v_129 = seed.word(130); + row[layout.auxiliaries + 127] = v_127; + row[layout.auxiliaries + 128] = v_128; + row[layout.auxiliaries + 129] = v_129; + switch (v_127) { + case 0ULL: { + const uint64_t v_130 = seed.word(131); + const uint64_t v_131 = seed.word(132); + const uint64_t v_132 = seed.word(133); + row[layout.auxiliaries + 130] = v_130; + row[layout.auxiliaries + 131] = v_131; + row[layout.auxiliaries + 132] = v_132; + switch (v_130) { + case 0ULL: { + const uint64_t v_133 = seed.word(134); + const uint64_t v_134 = seed.word(135); + const uint64_t v_135 = seed.word(136); + row[layout.auxiliaries + 133] = v_133; + row[layout.auxiliaries + 134] = v_134; + row[layout.auxiliaries + 135] = v_135; + switch (v_133) { + case 0ULL: { + const uint64_t v_136 = seed.word(137); + const uint64_t v_137 = seed.word(138); + const uint64_t v_138 = seed.word(139); + row[layout.auxiliaries + 136] = v_136; + row[layout.auxiliaries + 137] = v_137; + row[layout.auxiliaries + 138] = v_138; + switch (v_136) { + case 0ULL: { + const uint64_t v_139 = seed.word(140); + const uint64_t v_140 = seed.word(141); + const uint64_t v_141 = seed.word(142); + row[layout.auxiliaries + 139] = v_139; + row[layout.auxiliaries + 140] = v_140; + row[layout.auxiliaries + 141] = v_141; + switch (v_139) { + case 0ULL: { + const uint64_t v_142 = seed.word(143); + const uint64_t v_143 = seed.word(144); + const uint64_t v_144 = seed.word(145); + row[layout.auxiliaries + 142] = v_142; + row[layout.auxiliaries + 143] = v_143; + row[layout.auxiliaries + 144] = v_144; + switch (v_142) { + case 0ULL: { + const uint64_t v_145 = seed.word(146); + const uint64_t v_146 = seed.word(147); + const uint64_t v_147 = seed.word(148); + row[layout.auxiliaries + 145] = v_145; + row[layout.auxiliaries + 146] = v_146; + row[layout.auxiliaries + 147] = v_147; + switch (v_145) { + case 0ULL: { + const uint64_t v_148 = seed.word(149); + const uint64_t v_149 = seed.word(150); + const uint64_t v_150 = seed.word(151); + row[layout.auxiliaries + 148] = v_148; + row[layout.auxiliaries + 149] = v_149; + row[layout.auxiliaries + 150] = v_150; + switch (v_148) { + case 0ULL: { + const uint64_t v_151 = seed.word(152); + const uint64_t v_152 = seed.word(153); + const uint64_t v_153 = seed.word(154); + row[layout.auxiliaries + 151] = v_151; + row[layout.auxiliaries + 152] = v_152; + row[layout.auxiliaries + 153] = v_153; + switch (v_151) { + case 0ULL: { + const uint64_t v_154 = seed.word(155); + const uint64_t v_155 = seed.word(156); + const uint64_t v_156 = seed.word(157); + row[layout.auxiliaries + 154] = v_154; + row[layout.auxiliaries + 155] = v_155; + row[layout.auxiliaries + 156] = v_156; + switch (v_154) { + case 0ULL: { + const uint64_t v_157 = seed.word(158); + const uint64_t v_158 = seed.word(159); + const uint64_t v_159 = seed.word(160); + row[layout.auxiliaries + 157] = v_157; + row[layout.auxiliaries + 158] = v_158; + row[layout.auxiliaries + 159] = v_159; + switch (v_157) { + case 0ULL: { + const uint64_t v_160 = seed.word(161); + const uint64_t v_161 = seed.word(162); + const uint64_t v_162 = seed.word(163); + row[layout.auxiliaries + 160] = v_160; + row[layout.auxiliaries + 161] = v_161; + row[layout.auxiliaries + 162] = v_162; + switch (v_160) { + case 0ULL: { + const uint64_t v_163 = seed.word(164); + const uint64_t v_164 = seed.word(165); + const uint64_t v_165 = seed.word(166); + row[layout.auxiliaries + 163] = v_163; + row[layout.auxiliaries + 164] = v_164; + row[layout.auxiliaries + 165] = v_165; + switch (v_163) { + case 0ULL: { + const uint64_t v_166 = seed.word(167); + const uint64_t v_167 = seed.word(168); + const uint64_t v_168 = seed.word(169); + row[layout.auxiliaries + 166] = v_166; + row[layout.auxiliaries + 167] = v_167; + row[layout.auxiliaries + 168] = v_168; + switch (v_166) { + case 0ULL: { + const uint64_t v_169 = seed.word(170); + const uint64_t v_170 = seed.word(171); + const uint64_t v_171 = seed.word(172); + row[layout.auxiliaries + 169] = v_169; + row[layout.auxiliaries + 170] = v_170; + row[layout.auxiliaries + 171] = v_171; + switch (v_169) { + case 0ULL: { + const uint64_t v_172 = seed.word(173); + const uint64_t v_173 = seed.word(174); + const uint64_t v_174 = seed.word(175); + row[layout.auxiliaries + 172] = v_172; + row[layout.auxiliaries + 173] = v_173; + row[layout.auxiliaries + 174] = v_174; + switch (v_172) { + case 0ULL: { + const uint64_t v_175 = seed.word(176); + const uint64_t v_176 = seed.word(177); + const uint64_t v_177 = seed.word(178); + row[layout.auxiliaries + 175] = v_175; + row[layout.auxiliaries + 176] = v_176; + row[layout.auxiliaries + 177] = v_177; + switch (v_175) { + case 0ULL: { + const uint64_t v_178 = seed.word(179); + const uint64_t v_179 = seed.word(180); + const uint64_t v_180 = seed.word(181); + row[layout.auxiliaries + 178] = v_178; + row[layout.auxiliaries + 179] = v_179; + row[layout.auxiliaries + 180] = v_180; + switch (v_178) { + case 0ULL: { + const uint64_t v_181 = seed.word(182); + const uint64_t v_182 = seed.word(183); + const uint64_t v_183 = seed.word(184); + row[layout.auxiliaries + 181] = v_181; + row[layout.auxiliaries + 182] = v_182; + row[layout.auxiliaries + 183] = v_183; + switch (v_181) { + case 0ULL: { + const uint64_t v_184 = seed.word(185); + const uint64_t v_185 = seed.word(186); + const uint64_t v_186 = seed.word(187); + row[layout.auxiliaries + 184] = v_184; + row[layout.auxiliaries + 185] = v_185; + row[layout.auxiliaries + 186] = v_186; + switch (v_184) { + case 0ULL: { + const uint64_t v_187 = seed.word(188); + const uint64_t v_188 = seed.word(189); + const uint64_t v_189 = seed.word(190); + row[layout.auxiliaries + 187] = v_187; + row[layout.auxiliaries + 188] = v_188; + row[layout.auxiliaries + 189] = v_189; + switch (v_187) { + case 0ULL: { + const uint64_t v_190 = seed.word(191); + const uint64_t v_191 = seed.word(192); + const uint64_t v_192 = seed.word(193); + row[layout.auxiliaries + 190] = v_190; + row[layout.auxiliaries + 191] = v_191; + row[layout.auxiliaries + 192] = v_192; + switch (v_190) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_76(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 848 : 1552; + const Seed_multi_stark_76 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_76(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_76(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_76<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_76<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_76(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 193) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 848 : encoding == 0 ? 1552 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_76); +} + +__device__ __constant__ uint64_t inverse_78_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_3[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_4[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_5[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_6[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_7[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_8[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_9[] = {0ULL}; +template struct Seed_multi_stark_78 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 308); + case 3: return load_u64(data + 16); + case 4: return load_u32(data + 288); + case 5: return load_u32(data + 292); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + case 8: return load_u64(data + 40); + case 9: return load_u64(data + 48); + case 10: return load_u64(data + 56); + case 11: return load_u64(data + 64); + case 12: return load_u64(data + 72); + case 13: return load_u64(data + 80); + case 14: return load_u64(data + 88); + case 15: return load_u64(data + 96); + case 16: return load_u64(data + 104); + case 17: return load_u64(data + 112); + case 18: return load_u64(data + 120); + case 19: return load_u64(data + 128); + case 20: return load_u64(data + 136); + case 21: return load_u64(data + 144); + case 22: return load_u64(data + 152); + case 23: return load_u64(data + 160); + case 24: return load_u64(data + 168); + case 25: return load_u64(data + 176); + case 26: return load_u64(data + 184); + case 27: return load_u64(data + 192); + case 28: return load_u64(data + 200); + case 29: return load_u64(data + 208); + case 30: return load_u64(data + 216); + case 31: return load_u64(data + 224); + case 32: return load_u64(data + 232); + case 33: return load_u64(data + 240); + case 34: return load_u64(data + 248); + case 35: return load_u64(data + 256); + case 36: return load_u64(data + 264); + case 37: return load_u64(data + 272); + case 38: return load_u64(data + 280); + case 39: return load_u32(data + 296); + case 40: return load_u8(data + 309); + case 41: return load_u8(data + 310); + case 42: return load_u8(data + 311); + case 43: return load_u8(data + 312); + case 44: return load_u8(data + 313); + case 45: return load_u8(data + 314); + case 46: return load_u8(data + 315); + case 47: return load_u8(data + 316); + case 48: return load_u8(data + 317); + case 49: return load_u8(data + 318); + case 50: return load_u8(data + 319); + case 51: return load_u8(data + 320); + case 52: return load_u8(data + 321); + case 53: return load_u8(data + 322); + case 54: return load_u8(data + 323); + case 55: return load_u8(data + 324); + case 56: return load_u8(data + 325); + case 57: return load_u8(data + 326); + case 58: return load_u8(data + 327); + case 59: return load_u8(data + 328); + case 60: return load_u8(data + 329); + case 61: return load_u8(data + 330); + case 62: return load_u8(data + 331); + case 63: return load_u8(data + 332); + case 64: return load_u8(data + 333); + case 65: return load_u8(data + 334); + case 66: return load_u8(data + 335); + case 67: return load_u8(data + 336); + case 68: return load_u8(data + 337); + case 69: return load_u8(data + 338); + case 70: return load_u8(data + 339); + case 71: return load_u8(data + 340); + case 72: return load_u8(data + 341); + case 73: return load_u8(data + 342); + case 74: return load_u8(data + 343); + case 75: return load_u8(data + 344); + case 76: return load_u8(data + 345); + case 77: return load_u8(data + 346); + case 78: return load_u8(data + 347); + case 79: return load_u8(data + 348); + case 80: return load_u8(data + 349); + case 81: return load_u8(data + 350); + case 82: return load_u8(data + 351); + case 83: return load_u8(data + 352); + case 84: return load_u8(data + 353); + case 85: return load_u8(data + 354); + case 86: return load_u8(data + 355); + case 87: return load_u32(data + 300); + case 88: return load_u8(data + 356); + case 89: return load_u8(data + 357); + case 90: return load_u8(data + 358); + case 91: return load_u8(data + 359); + case 92: return load_u8(data + 360); + case 93: return load_u8(data + 361); + case 94: return load_u8(data + 362); + case 95: return load_u8(data + 363); + case 96: return load_u8(data + 364); + case 97: return load_u8(data + 365); + case 98: return load_u8(data + 366); + case 99: return load_u8(data + 367); + case 100: return load_u8(data + 368); + case 101: return load_u8(data + 369); + case 102: return load_u8(data + 370); + case 103: return load_u8(data + 371); + case 104: return load_u8(data + 372); + case 105: return load_u8(data + 373); + case 106: return load_u8(data + 374); + case 107: return load_u8(data + 375); + case 108: return load_u8(data + 376); + case 109: return load_u8(data + 377); + case 110: return load_u8(data + 378); + case 111: return load_u8(data + 379); + case 112: return load_u8(data + 380); + case 113: return load_u8(data + 381); + case 114: return load_u8(data + 382); + case 115: return load_u8(data + 383); + case 116: return load_u8(data + 384); + case 117: return load_u8(data + 385); + case 118: return load_u8(data + 386); + case 119: return load_u8(data + 387); + case 120: return load_u8(data + 388); + case 121: return load_u8(data + 389); + case 122: return load_u8(data + 390); + case 123: return load_u8(data + 391); + case 124: return load_u8(data + 392); + case 125: return load_u8(data + 393); + case 126: return load_u8(data + 394); + case 127: return load_u8(data + 395); + case 128: return load_u8(data + 396); + case 129: return load_u8(data + 397); + case 130: return load_u8(data + 398); + case 131: return load_u8(data + 399); + case 132: return load_u8(data + 400); + case 133: return load_u8(data + 401); + case 134: return load_u8(data + 402); + case 135: return load_u8(data + 403); + case 136: return load_u8(data + 404); + case 137: return load_u8(data + 405); + case 138: return load_u8(data + 406); + case 139: return load_u8(data + 407); + case 140: return load_u8(data + 408); + case 141: return load_u8(data + 409); + case 142: return load_u8(data + 410); + case 143: return load_u8(data + 411); + case 144: return load_u8(data + 412); + case 145: return load_u32(data + 304); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_78(Seed_multi_stark_78 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + switch (v_1) { + case 0ULL: { + switch (v_2) { + case 0ULL: { + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + switch (v_9) { + case 0ULL: { + switch (v_10) { + case 0ULL: { + switch (v_11) { + case 0ULL: { + switch (v_12) { + case 0ULL: { + switch (v_13) { + case 0ULL: { + switch (v_14) { + case 0ULL: { + switch (v_15) { + case 0ULL: { + switch (v_16) { + case 0ULL: { + const uint64_t v_19 = seed.word(15); + const uint64_t v_20 = seed.word(16); + const uint64_t v_21 = seed.word(17); + const uint64_t v_22 = seed.word(18); + const uint64_t v_23 = seed.word(19); + const uint64_t v_24 = seed.word(20); + const uint64_t v_25 = seed.word(21); + const uint64_t v_26 = seed.word(22); + const uint64_t v_27 = seed.word(23); + const uint64_t v_28 = seed.word(24); + const uint64_t v_29 = seed.word(25); + const uint64_t v_30 = seed.word(26); + const uint64_t v_31 = seed.word(27); + const uint64_t v_32 = seed.word(28); + const uint64_t v_33 = seed.word(29); + const uint64_t v_34 = seed.word(30); + const uint64_t v_35 = seed.word(31); + const uint64_t v_36 = seed.word(32); + const uint64_t v_37 = seed.word(33); + const uint64_t v_38 = seed.word(34); + const uint64_t v_39 = seed.word(35); + const uint64_t v_40 = seed.word(36); + const uint64_t v_41 = seed.word(37); + const uint64_t v_42 = seed.word(38); + const uint64_t v_43 = seed.word(39); + const uint64_t v_44 = seed.word(40); + const uint64_t v_45 = seed.word(41); + const uint64_t v_46 = seed.word(42); + const uint64_t v_47 = seed.word(43); + const uint64_t v_48 = seed.word(44); + const uint64_t v_49 = seed.word(45); + const uint64_t v_50 = seed.word(46); + row[layout.auxiliaries + 9] = v_19; + row[layout.auxiliaries + 10] = v_20; + row[layout.auxiliaries + 11] = v_21; + row[layout.auxiliaries + 12] = v_22; + row[layout.auxiliaries + 13] = v_23; + row[layout.auxiliaries + 14] = v_24; + row[layout.auxiliaries + 15] = v_25; + row[layout.auxiliaries + 16] = v_26; + row[layout.auxiliaries + 17] = v_27; + row[layout.auxiliaries + 18] = v_28; + row[layout.auxiliaries + 19] = v_29; + row[layout.auxiliaries + 20] = v_30; + row[layout.auxiliaries + 21] = v_31; + row[layout.auxiliaries + 22] = v_32; + row[layout.auxiliaries + 23] = v_33; + row[layout.auxiliaries + 24] = v_34; + row[layout.auxiliaries + 25] = v_35; + row[layout.auxiliaries + 26] = v_36; + row[layout.auxiliaries + 27] = v_37; + row[layout.auxiliaries + 28] = v_38; + row[layout.auxiliaries + 29] = v_39; + row[layout.auxiliaries + 30] = v_40; + row[layout.auxiliaries + 31] = v_41; + row[layout.auxiliaries + 32] = v_42; + row[layout.auxiliaries + 33] = v_43; + row[layout.auxiliaries + 34] = v_44; + row[layout.auxiliaries + 35] = v_45; + row[layout.auxiliaries + 36] = v_46; + row[layout.auxiliaries + 37] = v_47; + row[layout.auxiliaries + 38] = v_48; + row[layout.auxiliaries + 39] = v_49; + row[layout.auxiliaries + 40] = v_50; + const uint64_t v_52 = seed.word(47); + const uint64_t v_53 = seed.word(48); + const uint64_t v_54 = seed.word(49); + const uint64_t v_55 = seed.word(50); + const uint64_t v_56 = seed.word(51); + const uint64_t v_57 = seed.word(52); + const uint64_t v_58 = seed.word(53); + const uint64_t v_59 = seed.word(54); + row[layout.auxiliaries + 41] = v_52; + row[layout.auxiliaries + 42] = v_53; + row[layout.auxiliaries + 43] = v_54; + row[layout.auxiliaries + 44] = v_55; + row[layout.auxiliaries + 45] = v_56; + row[layout.auxiliaries + 46] = v_57; + row[layout.auxiliaries + 47] = v_58; + row[layout.auxiliaries + 48] = v_59; + const uint64_t v_75 = seed.word(55); + const uint64_t v_76 = seed.word(56); + const uint64_t v_77 = seed.word(57); + const uint64_t v_78 = seed.word(58); + const uint64_t v_79 = seed.word(59); + const uint64_t v_80 = seed.word(60); + const uint64_t v_81 = seed.word(61); + const uint64_t v_82 = seed.word(62); + const uint64_t v_83 = seed.word(63); + const uint64_t v_84 = seed.word(64); + const uint64_t v_85 = seed.word(65); + const uint64_t v_86 = seed.word(66); + const uint64_t v_87 = seed.word(67); + const uint64_t v_88 = seed.word(68); + const uint64_t v_89 = seed.word(69); + const uint64_t v_90 = seed.word(70); + const uint64_t v_91 = seed.word(71); + const uint64_t v_92 = seed.word(72); + const uint64_t v_93 = seed.word(73); + const uint64_t v_94 = seed.word(74); + const uint64_t v_95 = seed.word(75); + const uint64_t v_96 = seed.word(76); + const uint64_t v_97 = seed.word(77); + const uint64_t v_98 = seed.word(78); + const uint64_t v_99 = seed.word(79); + const uint64_t v_100 = seed.word(80); + const uint64_t v_101 = seed.word(81); + const uint64_t v_102 = seed.word(82); + const uint64_t v_103 = seed.word(83); + const uint64_t v_104 = seed.word(84); + const uint64_t v_105 = seed.word(85); + const uint64_t v_106 = seed.word(86); + row[layout.auxiliaries + 49] = v_75; + row[layout.auxiliaries + 50] = v_76; + row[layout.auxiliaries + 51] = v_77; + row[layout.auxiliaries + 52] = v_78; + row[layout.auxiliaries + 53] = v_79; + row[layout.auxiliaries + 54] = v_80; + row[layout.auxiliaries + 55] = v_81; + row[layout.auxiliaries + 56] = v_82; + row[layout.auxiliaries + 57] = v_83; + row[layout.auxiliaries + 58] = v_84; + row[layout.auxiliaries + 59] = v_85; + row[layout.auxiliaries + 60] = v_86; + row[layout.auxiliaries + 61] = v_87; + row[layout.auxiliaries + 62] = v_88; + row[layout.auxiliaries + 63] = v_89; + row[layout.auxiliaries + 64] = v_90; + row[layout.auxiliaries + 65] = v_91; + row[layout.auxiliaries + 66] = v_92; + row[layout.auxiliaries + 67] = v_93; + row[layout.auxiliaries + 68] = v_94; + row[layout.auxiliaries + 69] = v_95; + row[layout.auxiliaries + 70] = v_96; + row[layout.auxiliaries + 71] = v_97; + row[layout.auxiliaries + 72] = v_98; + row[layout.auxiliaries + 73] = v_99; + row[layout.auxiliaries + 74] = v_100; + row[layout.auxiliaries + 75] = v_101; + row[layout.auxiliaries + 76] = v_102; + row[layout.auxiliaries + 77] = v_103; + row[layout.auxiliaries + 78] = v_104; + row[layout.auxiliaries + 79] = v_105; + row[layout.auxiliaries + 80] = v_106; + const uint64_t v_107 = seed.word(87); + row[layout.auxiliaries + 81] = v_107; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_16 <= 0ULL ? inverse_78_0[v_16] : inverse(goldilocks_sub(v_16, 0ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_15 <= 0ULL ? inverse_78_1[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_14 <= 0ULL ? inverse_78_2[v_14] : inverse(goldilocks_sub(v_14, 0ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_13 <= 0ULL ? inverse_78_3[v_13] : inverse(goldilocks_sub(v_13, 0ULL))); + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_12 <= 0ULL ? inverse_78_4[v_12] : inverse(goldilocks_sub(v_12, 0ULL))); + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_11 <= 0ULL ? inverse_78_5[v_11] : inverse(goldilocks_sub(v_11, 0ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_10 <= 0ULL ? inverse_78_6[v_10] : inverse(goldilocks_sub(v_10, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_9 <= 0ULL ? inverse_78_7[v_9] : inverse(goldilocks_sub(v_9, 0ULL))); + row[layout.selectors + 8] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_2 <= 0ULL ? inverse_78_8[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_109 = seed.word(7); + const uint64_t v_110 = seed.word(8); + const uint64_t v_111 = seed.word(9); + const uint64_t v_112 = seed.word(10); + const uint64_t v_113 = seed.word(11); + const uint64_t v_114 = seed.word(12); + const uint64_t v_115 = seed.word(13); + const uint64_t v_116 = seed.word(14); + const uint64_t v_117 = seed.word(15); + const uint64_t v_118 = seed.word(16); + const uint64_t v_119 = seed.word(17); + const uint64_t v_120 = seed.word(18); + const uint64_t v_121 = seed.word(19); + const uint64_t v_122 = seed.word(20); + const uint64_t v_123 = seed.word(21); + const uint64_t v_124 = seed.word(22); + const uint64_t v_125 = seed.word(23); + const uint64_t v_126 = seed.word(24); + const uint64_t v_127 = seed.word(25); + const uint64_t v_128 = seed.word(26); + const uint64_t v_129 = seed.word(27); + const uint64_t v_130 = seed.word(28); + const uint64_t v_131 = seed.word(29); + const uint64_t v_132 = seed.word(30); + const uint64_t v_133 = seed.word(31); + const uint64_t v_134 = seed.word(32); + const uint64_t v_135 = seed.word(33); + const uint64_t v_136 = seed.word(34); + const uint64_t v_137 = seed.word(35); + const uint64_t v_138 = seed.word(36); + const uint64_t v_139 = seed.word(37); + const uint64_t v_140 = seed.word(38); + row[layout.auxiliaries + 2] = v_109; + row[layout.auxiliaries + 3] = v_110; + row[layout.auxiliaries + 4] = v_111; + row[layout.auxiliaries + 5] = v_112; + row[layout.auxiliaries + 6] = v_113; + row[layout.auxiliaries + 7] = v_114; + row[layout.auxiliaries + 8] = v_115; + row[layout.auxiliaries + 9] = v_116; + row[layout.auxiliaries + 10] = v_117; + row[layout.auxiliaries + 11] = v_118; + row[layout.auxiliaries + 12] = v_119; + row[layout.auxiliaries + 13] = v_120; + row[layout.auxiliaries + 14] = v_121; + row[layout.auxiliaries + 15] = v_122; + row[layout.auxiliaries + 16] = v_123; + row[layout.auxiliaries + 17] = v_124; + row[layout.auxiliaries + 18] = v_125; + row[layout.auxiliaries + 19] = v_126; + row[layout.auxiliaries + 20] = v_127; + row[layout.auxiliaries + 21] = v_128; + row[layout.auxiliaries + 22] = v_129; + row[layout.auxiliaries + 23] = v_130; + row[layout.auxiliaries + 24] = v_131; + row[layout.auxiliaries + 25] = v_132; + row[layout.auxiliaries + 26] = v_133; + row[layout.auxiliaries + 27] = v_134; + row[layout.auxiliaries + 28] = v_135; + row[layout.auxiliaries + 29] = v_136; + row[layout.auxiliaries + 30] = v_137; + row[layout.auxiliaries + 31] = v_138; + row[layout.auxiliaries + 32] = v_139; + row[layout.auxiliaries + 33] = v_140; + const uint64_t v_141 = seed.word(39); + row[layout.auxiliaries + 34] = v_141; + row[layout.selectors + 9] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_78_9[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_142 = seed.word(7); + const uint64_t v_143 = seed.word(8); + const uint64_t v_144 = seed.word(9); + const uint64_t v_145 = seed.word(10); + const uint64_t v_146 = seed.word(11); + const uint64_t v_147 = seed.word(12); + const uint64_t v_148 = seed.word(13); + const uint64_t v_149 = seed.word(14); + row[layout.auxiliaries + 2] = v_142; + row[layout.auxiliaries + 3] = v_143; + row[layout.auxiliaries + 4] = v_144; + row[layout.auxiliaries + 5] = v_145; + row[layout.auxiliaries + 6] = v_146; + row[layout.auxiliaries + 7] = v_147; + row[layout.auxiliaries + 8] = v_148; + row[layout.auxiliaries + 9] = v_149; + const uint64_t v_150 = seed.word(15); + row[layout.auxiliaries + 10] = v_150; + const uint64_t v_152 = goldilocks_sub(v_2, v_1); + const uint64_t v_153 = uint64_t(v_152 == 0); + row[layout.auxiliaries + 11] = inverse(v_152); + row[layout.auxiliaries + 12] = v_153; + const uint64_t v_159 = seed.word(16); + row[layout.auxiliaries + 13] = v_159; + const uint64_t v_160 = seed.word(17); + const uint64_t v_161 = seed.word(18); + const uint64_t v_162 = seed.word(19); + const uint64_t v_163 = seed.word(20); + const uint64_t v_164 = seed.word(21); + const uint64_t v_165 = seed.word(22); + const uint64_t v_166 = seed.word(23); + const uint64_t v_167 = seed.word(24); + const uint64_t v_168 = seed.word(25); + const uint64_t v_169 = seed.word(26); + const uint64_t v_170 = seed.word(27); + const uint64_t v_171 = seed.word(28); + const uint64_t v_172 = seed.word(29); + const uint64_t v_173 = seed.word(30); + const uint64_t v_174 = seed.word(31); + const uint64_t v_175 = seed.word(32); + const uint64_t v_176 = seed.word(33); + const uint64_t v_177 = seed.word(34); + const uint64_t v_178 = seed.word(35); + const uint64_t v_179 = seed.word(36); + const uint64_t v_180 = seed.word(37); + const uint64_t v_181 = seed.word(38); + const uint64_t v_182 = seed.word(39); + const uint64_t v_183 = seed.word(40); + const uint64_t v_184 = seed.word(41); + const uint64_t v_185 = seed.word(42); + const uint64_t v_186 = seed.word(43); + const uint64_t v_187 = seed.word(44); + const uint64_t v_188 = seed.word(45); + const uint64_t v_189 = seed.word(46); + const uint64_t v_190 = seed.word(47); + const uint64_t v_191 = seed.word(48); + const uint64_t v_192 = seed.word(49); + const uint64_t v_193 = seed.word(50); + const uint64_t v_194 = seed.word(51); + const uint64_t v_195 = seed.word(52); + const uint64_t v_196 = seed.word(53); + const uint64_t v_197 = seed.word(54); + const uint64_t v_198 = seed.word(55); + const uint64_t v_199 = seed.word(56); + const uint64_t v_200 = seed.word(57); + const uint64_t v_201 = seed.word(58); + const uint64_t v_202 = seed.word(59); + const uint64_t v_203 = seed.word(60); + const uint64_t v_204 = seed.word(61); + const uint64_t v_205 = seed.word(62); + const uint64_t v_206 = seed.word(63); + const uint64_t v_207 = seed.word(64); + const uint64_t v_208 = seed.word(65); + const uint64_t v_209 = seed.word(66); + const uint64_t v_210 = seed.word(67); + const uint64_t v_211 = seed.word(68); + const uint64_t v_212 = seed.word(69); + const uint64_t v_213 = seed.word(70); + const uint64_t v_214 = seed.word(71); + const uint64_t v_215 = seed.word(72); + const uint64_t v_216 = seed.word(73); + const uint64_t v_217 = seed.word(74); + const uint64_t v_218 = seed.word(75); + const uint64_t v_219 = seed.word(76); + const uint64_t v_220 = seed.word(77); + const uint64_t v_221 = seed.word(78); + const uint64_t v_222 = seed.word(79); + const uint64_t v_223 = seed.word(80); + row[layout.auxiliaries + 14] = v_160; + row[layout.auxiliaries + 15] = v_161; + row[layout.auxiliaries + 16] = v_162; + row[layout.auxiliaries + 17] = v_163; + row[layout.auxiliaries + 18] = v_164; + row[layout.auxiliaries + 19] = v_165; + row[layout.auxiliaries + 20] = v_166; + row[layout.auxiliaries + 21] = v_167; + row[layout.auxiliaries + 22] = v_168; + row[layout.auxiliaries + 23] = v_169; + row[layout.auxiliaries + 24] = v_170; + row[layout.auxiliaries + 25] = v_171; + row[layout.auxiliaries + 26] = v_172; + row[layout.auxiliaries + 27] = v_173; + row[layout.auxiliaries + 28] = v_174; + row[layout.auxiliaries + 29] = v_175; + row[layout.auxiliaries + 30] = v_176; + row[layout.auxiliaries + 31] = v_177; + row[layout.auxiliaries + 32] = v_178; + row[layout.auxiliaries + 33] = v_179; + row[layout.auxiliaries + 34] = v_180; + row[layout.auxiliaries + 35] = v_181; + row[layout.auxiliaries + 36] = v_182; + row[layout.auxiliaries + 37] = v_183; + row[layout.auxiliaries + 38] = v_184; + row[layout.auxiliaries + 39] = v_185; + row[layout.auxiliaries + 40] = v_186; + row[layout.auxiliaries + 41] = v_187; + row[layout.auxiliaries + 42] = v_188; + row[layout.auxiliaries + 43] = v_189; + row[layout.auxiliaries + 44] = v_190; + row[layout.auxiliaries + 45] = v_191; + row[layout.auxiliaries + 46] = v_192; + row[layout.auxiliaries + 47] = v_193; + row[layout.auxiliaries + 48] = v_194; + row[layout.auxiliaries + 49] = v_195; + row[layout.auxiliaries + 50] = v_196; + row[layout.auxiliaries + 51] = v_197; + row[layout.auxiliaries + 52] = v_198; + row[layout.auxiliaries + 53] = v_199; + row[layout.auxiliaries + 54] = v_200; + row[layout.auxiliaries + 55] = v_201; + row[layout.auxiliaries + 56] = v_202; + row[layout.auxiliaries + 57] = v_203; + row[layout.auxiliaries + 58] = v_204; + row[layout.auxiliaries + 59] = v_205; + row[layout.auxiliaries + 60] = v_206; + row[layout.auxiliaries + 61] = v_207; + row[layout.auxiliaries + 62] = v_208; + row[layout.auxiliaries + 63] = v_209; + row[layout.auxiliaries + 64] = v_210; + row[layout.auxiliaries + 65] = v_211; + row[layout.auxiliaries + 66] = v_212; + row[layout.auxiliaries + 67] = v_213; + row[layout.auxiliaries + 68] = v_214; + row[layout.auxiliaries + 69] = v_215; + row[layout.auxiliaries + 70] = v_216; + row[layout.auxiliaries + 71] = v_217; + row[layout.auxiliaries + 72] = v_218; + row[layout.auxiliaries + 73] = v_219; + row[layout.auxiliaries + 74] = v_220; + row[layout.auxiliaries + 75] = v_221; + row[layout.auxiliaries + 76] = v_222; + row[layout.auxiliaries + 77] = v_223; + const uint64_t v_224 = seed.word(81); + const uint64_t v_225 = seed.word(82); + const uint64_t v_226 = seed.word(83); + const uint64_t v_227 = seed.word(84); + const uint64_t v_228 = seed.word(85); + const uint64_t v_229 = seed.word(86); + const uint64_t v_230 = seed.word(87); + const uint64_t v_231 = seed.word(88); + const uint64_t v_232 = seed.word(89); + const uint64_t v_233 = seed.word(90); + const uint64_t v_234 = seed.word(91); + const uint64_t v_235 = seed.word(92); + const uint64_t v_236 = seed.word(93); + const uint64_t v_237 = seed.word(94); + const uint64_t v_238 = seed.word(95); + const uint64_t v_239 = seed.word(96); + const uint64_t v_240 = seed.word(97); + const uint64_t v_241 = seed.word(98); + const uint64_t v_242 = seed.word(99); + const uint64_t v_243 = seed.word(100); + const uint64_t v_244 = seed.word(101); + const uint64_t v_245 = seed.word(102); + const uint64_t v_246 = seed.word(103); + const uint64_t v_247 = seed.word(104); + const uint64_t v_248 = seed.word(105); + const uint64_t v_249 = seed.word(106); + const uint64_t v_250 = seed.word(107); + const uint64_t v_251 = seed.word(108); + const uint64_t v_252 = seed.word(109); + const uint64_t v_253 = seed.word(110); + const uint64_t v_254 = seed.word(111); + const uint64_t v_255 = seed.word(112); + row[layout.auxiliaries + 78] = v_224; + row[layout.auxiliaries + 79] = v_225; + row[layout.auxiliaries + 80] = v_226; + row[layout.auxiliaries + 81] = v_227; + row[layout.auxiliaries + 82] = v_228; + row[layout.auxiliaries + 83] = v_229; + row[layout.auxiliaries + 84] = v_230; + row[layout.auxiliaries + 85] = v_231; + row[layout.auxiliaries + 86] = v_232; + row[layout.auxiliaries + 87] = v_233; + row[layout.auxiliaries + 88] = v_234; + row[layout.auxiliaries + 89] = v_235; + row[layout.auxiliaries + 90] = v_236; + row[layout.auxiliaries + 91] = v_237; + row[layout.auxiliaries + 92] = v_238; + row[layout.auxiliaries + 93] = v_239; + row[layout.auxiliaries + 94] = v_240; + row[layout.auxiliaries + 95] = v_241; + row[layout.auxiliaries + 96] = v_242; + row[layout.auxiliaries + 97] = v_243; + row[layout.auxiliaries + 98] = v_244; + row[layout.auxiliaries + 99] = v_245; + row[layout.auxiliaries + 100] = v_246; + row[layout.auxiliaries + 101] = v_247; + row[layout.auxiliaries + 102] = v_248; + row[layout.auxiliaries + 103] = v_249; + row[layout.auxiliaries + 104] = v_250; + row[layout.auxiliaries + 105] = v_251; + row[layout.auxiliaries + 106] = v_252; + row[layout.auxiliaries + 107] = v_253; + row[layout.auxiliaries + 108] = v_254; + row[layout.auxiliaries + 109] = v_255; + const uint64_t v_272 = seed.word(113); + const uint64_t v_273 = seed.word(114); + const uint64_t v_274 = seed.word(115); + const uint64_t v_275 = seed.word(116); + const uint64_t v_276 = seed.word(117); + const uint64_t v_277 = seed.word(118); + const uint64_t v_278 = seed.word(119); + const uint64_t v_279 = seed.word(120); + const uint64_t v_280 = seed.word(121); + const uint64_t v_281 = seed.word(122); + const uint64_t v_282 = seed.word(123); + const uint64_t v_283 = seed.word(124); + const uint64_t v_284 = seed.word(125); + const uint64_t v_285 = seed.word(126); + const uint64_t v_286 = seed.word(127); + const uint64_t v_287 = seed.word(128); + const uint64_t v_288 = seed.word(129); + const uint64_t v_289 = seed.word(130); + const uint64_t v_290 = seed.word(131); + const uint64_t v_291 = seed.word(132); + const uint64_t v_292 = seed.word(133); + const uint64_t v_293 = seed.word(134); + const uint64_t v_294 = seed.word(135); + const uint64_t v_295 = seed.word(136); + const uint64_t v_296 = seed.word(137); + const uint64_t v_297 = seed.word(138); + const uint64_t v_298 = seed.word(139); + const uint64_t v_299 = seed.word(140); + const uint64_t v_300 = seed.word(141); + const uint64_t v_301 = seed.word(142); + const uint64_t v_302 = seed.word(143); + const uint64_t v_303 = seed.word(144); + row[layout.auxiliaries + 110] = v_272; + row[layout.auxiliaries + 111] = v_273; + row[layout.auxiliaries + 112] = v_274; + row[layout.auxiliaries + 113] = v_275; + row[layout.auxiliaries + 114] = v_276; + row[layout.auxiliaries + 115] = v_277; + row[layout.auxiliaries + 116] = v_278; + row[layout.auxiliaries + 117] = v_279; + row[layout.auxiliaries + 118] = v_280; + row[layout.auxiliaries + 119] = v_281; + row[layout.auxiliaries + 120] = v_282; + row[layout.auxiliaries + 121] = v_283; + row[layout.auxiliaries + 122] = v_284; + row[layout.auxiliaries + 123] = v_285; + row[layout.auxiliaries + 124] = v_286; + row[layout.auxiliaries + 125] = v_287; + row[layout.auxiliaries + 126] = v_288; + row[layout.auxiliaries + 127] = v_289; + row[layout.auxiliaries + 128] = v_290; + row[layout.auxiliaries + 129] = v_291; + row[layout.auxiliaries + 130] = v_292; + row[layout.auxiliaries + 131] = v_293; + row[layout.auxiliaries + 132] = v_294; + row[layout.auxiliaries + 133] = v_295; + row[layout.auxiliaries + 134] = v_296; + row[layout.auxiliaries + 135] = v_297; + row[layout.auxiliaries + 136] = v_298; + row[layout.auxiliaries + 137] = v_299; + row[layout.auxiliaries + 138] = v_300; + row[layout.auxiliaries + 139] = v_301; + row[layout.auxiliaries + 140] = v_302; + row[layout.auxiliaries + 141] = v_303; + const uint64_t v_304 = seed.word(145); + row[layout.auxiliaries + 142] = v_304; + row[layout.selectors + 10] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_78(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 416 : 1168; + const Seed_multi_stark_78 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_78(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_78(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_78<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_78<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_78(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 11 || width < auxiliaries || width - auxiliaries < 143) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 416 : encoding == 0 ? 1168 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_78); +} + +template struct Seed_multi_stark_79 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u32(data + 100); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 104); + case 5: return load_u32(data + 108); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 128); + case 8: return load_u8(data + 129); + case 9: return load_u8(data + 130); + case 10: return load_u8(data + 131); + case 11: return load_u8(data + 132); + case 12: return load_u8(data + 133); + case 13: return load_u8(data + 134); + case 14: return load_u8(data + 135); + case 15: return load_u8(data + 136); + case 16: return load_u8(data + 137); + case 17: return load_u8(data + 138); + case 18: return load_u8(data + 139); + case 19: return load_u8(data + 140); + case 20: return load_u8(data + 141); + case 21: return load_u8(data + 142); + case 22: return load_u8(data + 143); + case 23: return load_u8(data + 144); + case 24: return load_u8(data + 145); + case 25: return load_u8(data + 146); + case 26: return load_u8(data + 147); + case 27: return load_u8(data + 148); + case 28: return load_u8(data + 149); + case 29: return load_u8(data + 150); + case 30: return load_u8(data + 151); + case 31: return load_u8(data + 152); + case 32: return load_u8(data + 153); + case 33: return load_u8(data + 154); + case 34: return load_u8(data + 155); + case 35: return load_u8(data + 156); + case 36: return load_u8(data + 157); + case 37: return load_u8(data + 158); + case 38: return load_u8(data + 159); + case 39: return load_u8(data + 160); + case 40: return load_u8(data + 161); + case 41: return load_u8(data + 162); + case 42: return load_u8(data + 163); + case 43: return load_u8(data + 164); + case 44: return load_u8(data + 165); + case 45: return load_u8(data + 166); + case 46: return load_u8(data + 167); + case 47: return load_u8(data + 168); + case 48: return load_u8(data + 169); + case 49: return load_u8(data + 170); + case 50: return load_u8(data + 171); + case 51: return load_u8(data + 172); + case 52: return load_u8(data + 173); + case 53: return load_u8(data + 174); + case 54: return load_u8(data + 175); + case 55: return load_u8(data + 176); + case 56: return load_u8(data + 177); + case 57: return load_u8(data + 178); + case 58: return load_u8(data + 179); + case 59: return load_u8(data + 180); + case 60: return load_u8(data + 181); + case 61: return load_u8(data + 182); + case 62: return load_u8(data + 183); + case 63: return load_u8(data + 184); + case 64: return load_u8(data + 185); + case 65: return load_u8(data + 186); + case 66: return load_u8(data + 187); + case 67: return load_u8(data + 188); + case 68: return load_u8(data + 189); + case 69: return load_u8(data + 190); + case 70: return load_u8(data + 191); + case 71: return load_u8(data + 192); + case 72: return load_u8(data + 193); + case 73: return load_u8(data + 194); + case 74: return load_u8(data + 195); + case 75: return load_u8(data + 196); + case 76: return load_u8(data + 197); + case 77: return load_u8(data + 198); + case 78: return load_u8(data + 199); + case 79: return load_u8(data + 200); + case 80: return load_u8(data + 201); + case 81: return load_u8(data + 202); + case 82: return load_u8(data + 203); + case 83: return load_u8(data + 204); + case 84: return load_u8(data + 205); + case 85: return load_u8(data + 206); + case 86: return load_u8(data + 207); + case 87: return load_u8(data + 208); + case 88: return load_u8(data + 209); + case 89: return load_u8(data + 210); + case 90: return load_u8(data + 211); + case 91: return load_u8(data + 212); + case 92: return load_u8(data + 213); + case 93: return load_u8(data + 214); + case 94: return load_u8(data + 215); + case 95: return load_u8(data + 216); + case 96: return load_u8(data + 217); + case 97: return load_u8(data + 218); + case 98: return load_u8(data + 219); + case 99: return load_u8(data + 220); + case 100: return load_u8(data + 221); + case 101: return load_u8(data + 222); + case 102: return load_u8(data + 223); + case 103: return load_u8(data + 224); + case 104: return load_u8(data + 225); + case 105: return load_u8(data + 226); + case 106: return load_u8(data + 227); + case 107: return load_u8(data + 228); + case 108: return load_u8(data + 229); + case 109: return load_u8(data + 230); + case 110: return load_u8(data + 231); + case 111: return load_u8(data + 232); + case 112: return load_u8(data + 233); + case 113: return load_u8(data + 234); + case 114: return load_u8(data + 235); + case 115: return load_u8(data + 236); + case 116: return load_u8(data + 237); + case 117: return load_u8(data + 238); + case 118: return load_u8(data + 239); + case 119: return load_u8(data + 240); + case 120: return load_u8(data + 241); + case 121: return load_u8(data + 242); + case 122: return load_u8(data + 243); + case 123: return load_u8(data + 244); + case 124: return load_u8(data + 245); + case 125: return load_u8(data + 246); + case 126: return load_u8(data + 247); + case 127: return load_u8(data + 248); + case 128: return load_u8(data + 249); + case 129: return load_u8(data + 250); + case 130: return load_u8(data + 251); + case 131: return load_u8(data + 252); + case 132: return load_u8(data + 253); + case 133: return load_u8(data + 254); + case 134: return load_u8(data + 255); + case 135: return load_u8(data + 256); + case 136: return load_u8(data + 257); + case 137: return load_u8(data + 258); + case 138: return load_u8(data + 259); + case 139: return load_u8(data + 260); + case 140: return load_u8(data + 261); + case 141: return load_u8(data + 262); + case 142: return load_u8(data + 263); + case 143: return load_u8(data + 264); + case 144: return load_u8(data + 265); + case 145: return load_u32(data + 112); + case 146: return load_u32(data + 116); + case 147: return load_u64(data + 24); + case 148: return load_u64(data + 32); + case 149: return load_u64(data + 40); + case 150: return load_u64(data + 48); + case 151: return load_u64(data + 56); + case 152: return load_u64(data + 64); + case 153: return load_u64(data + 72); + case 154: return load_u64(data + 80); + case 155: return load_u32(data + 120); + case 156: return load_u32(data + 124); + case 157: return load_u64(data + 88); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_79(Seed_multi_stark_79 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_8 = 8ULL; + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + const uint64_t v_23 = seed.word(21); + const uint64_t v_24 = seed.word(22); + const uint64_t v_25 = seed.word(23); + const uint64_t v_26 = seed.word(24); + const uint64_t v_27 = seed.word(25); + const uint64_t v_28 = seed.word(26); + const uint64_t v_29 = seed.word(27); + const uint64_t v_30 = seed.word(28); + const uint64_t v_31 = seed.word(29); + const uint64_t v_32 = seed.word(30); + const uint64_t v_33 = seed.word(31); + const uint64_t v_34 = seed.word(32); + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + const uint64_t v_44 = seed.word(42); + const uint64_t v_45 = seed.word(43); + const uint64_t v_46 = seed.word(44); + const uint64_t v_47 = seed.word(45); + const uint64_t v_48 = seed.word(46); + const uint64_t v_49 = seed.word(47); + const uint64_t v_50 = seed.word(48); + const uint64_t v_51 = seed.word(49); + const uint64_t v_52 = seed.word(50); + const uint64_t v_53 = seed.word(51); + const uint64_t v_54 = seed.word(52); + const uint64_t v_55 = seed.word(53); + const uint64_t v_56 = seed.word(54); + const uint64_t v_57 = seed.word(55); + const uint64_t v_58 = seed.word(56); + const uint64_t v_59 = seed.word(57); + const uint64_t v_60 = seed.word(58); + const uint64_t v_61 = seed.word(59); + const uint64_t v_62 = seed.word(60); + const uint64_t v_63 = seed.word(61); + const uint64_t v_64 = seed.word(62); + const uint64_t v_65 = seed.word(63); + const uint64_t v_66 = seed.word(64); + const uint64_t v_67 = seed.word(65); + const uint64_t v_68 = seed.word(66); + const uint64_t v_69 = seed.word(67); + const uint64_t v_70 = seed.word(68); + const uint64_t v_71 = seed.word(69); + const uint64_t v_72 = seed.word(70); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + row[layout.auxiliaries + 15] = v_23; + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + row[layout.auxiliaries + 18] = v_26; + row[layout.auxiliaries + 19] = v_27; + row[layout.auxiliaries + 20] = v_28; + row[layout.auxiliaries + 21] = v_29; + row[layout.auxiliaries + 22] = v_30; + row[layout.auxiliaries + 23] = v_31; + row[layout.auxiliaries + 24] = v_32; + row[layout.auxiliaries + 25] = v_33; + row[layout.auxiliaries + 26] = v_34; + row[layout.auxiliaries + 27] = v_35; + row[layout.auxiliaries + 28] = v_36; + row[layout.auxiliaries + 29] = v_37; + row[layout.auxiliaries + 30] = v_38; + row[layout.auxiliaries + 31] = v_39; + row[layout.auxiliaries + 32] = v_40; + row[layout.auxiliaries + 33] = v_41; + row[layout.auxiliaries + 34] = v_42; + row[layout.auxiliaries + 35] = v_43; + row[layout.auxiliaries + 36] = v_44; + row[layout.auxiliaries + 37] = v_45; + row[layout.auxiliaries + 38] = v_46; + row[layout.auxiliaries + 39] = v_47; + row[layout.auxiliaries + 40] = v_48; + row[layout.auxiliaries + 41] = v_49; + row[layout.auxiliaries + 42] = v_50; + row[layout.auxiliaries + 43] = v_51; + row[layout.auxiliaries + 44] = v_52; + row[layout.auxiliaries + 45] = v_53; + row[layout.auxiliaries + 46] = v_54; + row[layout.auxiliaries + 47] = v_55; + row[layout.auxiliaries + 48] = v_56; + row[layout.auxiliaries + 49] = v_57; + row[layout.auxiliaries + 50] = v_58; + row[layout.auxiliaries + 51] = v_59; + row[layout.auxiliaries + 52] = v_60; + row[layout.auxiliaries + 53] = v_61; + row[layout.auxiliaries + 54] = v_62; + row[layout.auxiliaries + 55] = v_63; + row[layout.auxiliaries + 56] = v_64; + row[layout.auxiliaries + 57] = v_65; + row[layout.auxiliaries + 58] = v_66; + row[layout.auxiliaries + 59] = v_67; + row[layout.auxiliaries + 60] = v_68; + row[layout.auxiliaries + 61] = v_69; + row[layout.auxiliaries + 62] = v_70; + row[layout.auxiliaries + 63] = v_71; + row[layout.auxiliaries + 64] = v_72; + switch (v_2) { + case 1023ULL: { + const uint64_t v_73 = seed.word(71); + row[layout.auxiliaries + 65] = v_73; + const uint64_t v_74 = seed.word(72); + const uint64_t v_75 = seed.word(73); + const uint64_t v_76 = seed.word(74); + const uint64_t v_77 = seed.word(75); + const uint64_t v_78 = seed.word(76); + const uint64_t v_79 = seed.word(77); + const uint64_t v_80 = seed.word(78); + const uint64_t v_81 = seed.word(79); + row[layout.auxiliaries + 66] = v_74; + row[layout.auxiliaries + 67] = v_75; + row[layout.auxiliaries + 68] = v_76; + row[layout.auxiliaries + 69] = v_77; + row[layout.auxiliaries + 70] = v_78; + row[layout.auxiliaries + 71] = v_79; + row[layout.auxiliaries + 72] = v_80; + row[layout.auxiliaries + 73] = v_81; + const uint64_t v_82 = seed.word(80); + row[layout.auxiliaries + 74] = v_82; + const uint64_t v_83 = goldilocks_mul(v_73, v_82); + row[layout.auxiliaries + 75] = v_83; + const uint64_t v_117 = seed.word(81); + const uint64_t v_118 = seed.word(82); + const uint64_t v_119 = seed.word(83); + const uint64_t v_120 = seed.word(84); + const uint64_t v_121 = seed.word(85); + const uint64_t v_122 = seed.word(86); + const uint64_t v_123 = seed.word(87); + const uint64_t v_124 = seed.word(88); + const uint64_t v_125 = seed.word(89); + const uint64_t v_126 = seed.word(90); + const uint64_t v_127 = seed.word(91); + const uint64_t v_128 = seed.word(92); + const uint64_t v_129 = seed.word(93); + const uint64_t v_130 = seed.word(94); + const uint64_t v_131 = seed.word(95); + const uint64_t v_132 = seed.word(96); + const uint64_t v_133 = seed.word(97); + const uint64_t v_134 = seed.word(98); + const uint64_t v_135 = seed.word(99); + const uint64_t v_136 = seed.word(100); + const uint64_t v_137 = seed.word(101); + const uint64_t v_138 = seed.word(102); + const uint64_t v_139 = seed.word(103); + const uint64_t v_140 = seed.word(104); + const uint64_t v_141 = seed.word(105); + const uint64_t v_142 = seed.word(106); + const uint64_t v_143 = seed.word(107); + const uint64_t v_144 = seed.word(108); + const uint64_t v_145 = seed.word(109); + const uint64_t v_146 = seed.word(110); + const uint64_t v_147 = seed.word(111); + const uint64_t v_148 = seed.word(112); + row[layout.auxiliaries + 76] = v_117; + row[layout.auxiliaries + 77] = v_118; + row[layout.auxiliaries + 78] = v_119; + row[layout.auxiliaries + 79] = v_120; + row[layout.auxiliaries + 80] = v_121; + row[layout.auxiliaries + 81] = v_122; + row[layout.auxiliaries + 82] = v_123; + row[layout.auxiliaries + 83] = v_124; + row[layout.auxiliaries + 84] = v_125; + row[layout.auxiliaries + 85] = v_126; + row[layout.auxiliaries + 86] = v_127; + row[layout.auxiliaries + 87] = v_128; + row[layout.auxiliaries + 88] = v_129; + row[layout.auxiliaries + 89] = v_130; + row[layout.auxiliaries + 90] = v_131; + row[layout.auxiliaries + 91] = v_132; + row[layout.auxiliaries + 92] = v_133; + row[layout.auxiliaries + 93] = v_134; + row[layout.auxiliaries + 94] = v_135; + row[layout.auxiliaries + 95] = v_136; + row[layout.auxiliaries + 96] = v_137; + row[layout.auxiliaries + 97] = v_138; + row[layout.auxiliaries + 98] = v_139; + row[layout.auxiliaries + 99] = v_140; + row[layout.auxiliaries + 100] = v_141; + row[layout.auxiliaries + 101] = v_142; + row[layout.auxiliaries + 102] = v_143; + row[layout.auxiliaries + 103] = v_144; + row[layout.auxiliaries + 104] = v_145; + row[layout.auxiliaries + 105] = v_146; + row[layout.auxiliaries + 106] = v_147; + row[layout.auxiliaries + 107] = v_148; + const uint64_t v_151 = seed.word(113); + const uint64_t v_152 = seed.word(114); + const uint64_t v_153 = seed.word(115); + const uint64_t v_154 = seed.word(116); + const uint64_t v_155 = seed.word(117); + const uint64_t v_156 = seed.word(118); + const uint64_t v_157 = seed.word(119); + const uint64_t v_158 = seed.word(120); + const uint64_t v_159 = seed.word(121); + const uint64_t v_160 = seed.word(122); + const uint64_t v_161 = seed.word(123); + const uint64_t v_162 = seed.word(124); + const uint64_t v_163 = seed.word(125); + const uint64_t v_164 = seed.word(126); + const uint64_t v_165 = seed.word(127); + const uint64_t v_166 = seed.word(128); + const uint64_t v_167 = seed.word(129); + const uint64_t v_168 = seed.word(130); + const uint64_t v_169 = seed.word(131); + const uint64_t v_170 = seed.word(132); + const uint64_t v_171 = seed.word(133); + const uint64_t v_172 = seed.word(134); + const uint64_t v_173 = seed.word(135); + const uint64_t v_174 = seed.word(136); + const uint64_t v_175 = seed.word(137); + const uint64_t v_176 = seed.word(138); + const uint64_t v_177 = seed.word(139); + const uint64_t v_178 = seed.word(140); + const uint64_t v_179 = seed.word(141); + const uint64_t v_180 = seed.word(142); + const uint64_t v_181 = seed.word(143); + const uint64_t v_182 = seed.word(144); + row[layout.auxiliaries + 108] = v_151; + row[layout.auxiliaries + 109] = v_152; + row[layout.auxiliaries + 110] = v_153; + row[layout.auxiliaries + 111] = v_154; + row[layout.auxiliaries + 112] = v_155; + row[layout.auxiliaries + 113] = v_156; + row[layout.auxiliaries + 114] = v_157; + row[layout.auxiliaries + 115] = v_158; + row[layout.auxiliaries + 116] = v_159; + row[layout.auxiliaries + 117] = v_160; + row[layout.auxiliaries + 118] = v_161; + row[layout.auxiliaries + 119] = v_162; + row[layout.auxiliaries + 120] = v_163; + row[layout.auxiliaries + 121] = v_164; + row[layout.auxiliaries + 122] = v_165; + row[layout.auxiliaries + 123] = v_166; + row[layout.auxiliaries + 124] = v_167; + row[layout.auxiliaries + 125] = v_168; + row[layout.auxiliaries + 126] = v_169; + row[layout.auxiliaries + 127] = v_170; + row[layout.auxiliaries + 128] = v_171; + row[layout.auxiliaries + 129] = v_172; + row[layout.auxiliaries + 130] = v_173; + row[layout.auxiliaries + 131] = v_174; + row[layout.auxiliaries + 132] = v_175; + row[layout.auxiliaries + 133] = v_176; + row[layout.auxiliaries + 134] = v_177; + row[layout.auxiliaries + 135] = v_178; + row[layout.auxiliaries + 136] = v_179; + row[layout.auxiliaries + 137] = v_180; + row[layout.auxiliaries + 138] = v_181; + row[layout.auxiliaries + 139] = v_182; + const uint64_t v_183 = seed.word(145); + row[layout.auxiliaries + 140] = v_183; + const uint64_t v_185 = seed.word(146); + row[layout.auxiliaries + 141] = v_185; + const uint64_t v_186 = seed.word(147); + const uint64_t v_187 = seed.word(148); + const uint64_t v_188 = seed.word(149); + const uint64_t v_189 = seed.word(150); + const uint64_t v_190 = seed.word(151); + const uint64_t v_191 = seed.word(152); + const uint64_t v_192 = seed.word(153); + const uint64_t v_193 = seed.word(154); + row[layout.auxiliaries + 142] = v_186; + row[layout.auxiliaries + 143] = v_187; + row[layout.auxiliaries + 144] = v_188; + row[layout.auxiliaries + 145] = v_189; + row[layout.auxiliaries + 146] = v_190; + row[layout.auxiliaries + 147] = v_191; + row[layout.auxiliaries + 148] = v_192; + row[layout.auxiliaries + 149] = v_193; + const uint64_t v_194 = seed.word(155); + row[layout.auxiliaries + 150] = v_194; + const uint64_t v_195 = seed.word(156); + row[layout.auxiliaries + 151] = v_195; + const uint64_t v_196 = seed.word(157); + row[layout.auxiliaries + 152] = v_196; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 65] = inverse(goldilocks_sub(v_2, 1023ULL)); + const uint64_t v_197 = seed.word(71); + row[layout.auxiliaries + 66] = v_197; + const uint64_t v_199 = seed.word(72); + row[layout.auxiliaries + 67] = v_199; + const uint64_t v_200 = seed.word(73); + const uint64_t v_201 = seed.word(74); + const uint64_t v_202 = seed.word(75); + const uint64_t v_203 = seed.word(76); + const uint64_t v_204 = seed.word(77); + const uint64_t v_205 = seed.word(78); + const uint64_t v_206 = seed.word(79); + const uint64_t v_207 = seed.word(80); + row[layout.auxiliaries + 68] = v_200; + row[layout.auxiliaries + 69] = v_201; + row[layout.auxiliaries + 70] = v_202; + row[layout.auxiliaries + 71] = v_203; + row[layout.auxiliaries + 72] = v_204; + row[layout.auxiliaries + 73] = v_205; + row[layout.auxiliaries + 74] = v_206; + row[layout.auxiliaries + 75] = v_207; + const uint64_t v_208 = seed.word(81); + row[layout.auxiliaries + 76] = v_208; + const uint64_t v_209 = goldilocks_mul(v_208, v_8); + const uint64_t v_210 = goldilocks_mul(v_199, v_209); + row[layout.auxiliaries + 77] = v_210; + const uint64_t v_211 = 63ULL; + const uint64_t v_212 = goldilocks_sub(v_2, v_211); + const uint64_t v_213 = uint64_t(v_212 == 0); + row[layout.auxiliaries + 78] = inverse(v_212); + row[layout.auxiliaries + 79] = v_213; + const uint64_t v_217 = seed.word(82); + const uint64_t v_218 = seed.word(83); + const uint64_t v_219 = seed.word(84); + const uint64_t v_220 = seed.word(85); + const uint64_t v_221 = seed.word(86); + const uint64_t v_222 = seed.word(87); + const uint64_t v_223 = seed.word(88); + const uint64_t v_224 = seed.word(89); + const uint64_t v_225 = seed.word(90); + const uint64_t v_226 = seed.word(91); + const uint64_t v_227 = seed.word(92); + const uint64_t v_228 = seed.word(93); + const uint64_t v_229 = seed.word(94); + const uint64_t v_230 = seed.word(95); + const uint64_t v_231 = seed.word(96); + const uint64_t v_232 = seed.word(97); + const uint64_t v_233 = seed.word(98); + const uint64_t v_234 = seed.word(99); + const uint64_t v_235 = seed.word(100); + const uint64_t v_236 = seed.word(101); + const uint64_t v_237 = seed.word(102); + const uint64_t v_238 = seed.word(103); + const uint64_t v_239 = seed.word(104); + const uint64_t v_240 = seed.word(105); + const uint64_t v_241 = seed.word(106); + const uint64_t v_242 = seed.word(107); + const uint64_t v_243 = seed.word(108); + const uint64_t v_244 = seed.word(109); + const uint64_t v_245 = seed.word(110); + const uint64_t v_246 = seed.word(111); + const uint64_t v_247 = seed.word(112); + const uint64_t v_248 = seed.word(113); + row[layout.auxiliaries + 80] = v_217; + row[layout.auxiliaries + 81] = v_218; + row[layout.auxiliaries + 82] = v_219; + row[layout.auxiliaries + 83] = v_220; + row[layout.auxiliaries + 84] = v_221; + row[layout.auxiliaries + 85] = v_222; + row[layout.auxiliaries + 86] = v_223; + row[layout.auxiliaries + 87] = v_224; + row[layout.auxiliaries + 88] = v_225; + row[layout.auxiliaries + 89] = v_226; + row[layout.auxiliaries + 90] = v_227; + row[layout.auxiliaries + 91] = v_228; + row[layout.auxiliaries + 92] = v_229; + row[layout.auxiliaries + 93] = v_230; + row[layout.auxiliaries + 94] = v_231; + row[layout.auxiliaries + 95] = v_232; + row[layout.auxiliaries + 96] = v_233; + row[layout.auxiliaries + 97] = v_234; + row[layout.auxiliaries + 98] = v_235; + row[layout.auxiliaries + 99] = v_236; + row[layout.auxiliaries + 100] = v_237; + row[layout.auxiliaries + 101] = v_238; + row[layout.auxiliaries + 102] = v_239; + row[layout.auxiliaries + 103] = v_240; + row[layout.auxiliaries + 104] = v_241; + row[layout.auxiliaries + 105] = v_242; + row[layout.auxiliaries + 106] = v_243; + row[layout.auxiliaries + 107] = v_244; + row[layout.auxiliaries + 108] = v_245; + row[layout.auxiliaries + 109] = v_246; + row[layout.auxiliaries + 110] = v_247; + row[layout.auxiliaries + 111] = v_248; + const uint64_t v_266 = seed.word(114); + const uint64_t v_267 = seed.word(115); + const uint64_t v_268 = seed.word(116); + const uint64_t v_269 = seed.word(117); + const uint64_t v_270 = seed.word(118); + const uint64_t v_271 = seed.word(119); + const uint64_t v_272 = seed.word(120); + const uint64_t v_273 = seed.word(121); + const uint64_t v_274 = seed.word(122); + const uint64_t v_275 = seed.word(123); + const uint64_t v_276 = seed.word(124); + const uint64_t v_277 = seed.word(125); + const uint64_t v_278 = seed.word(126); + const uint64_t v_279 = seed.word(127); + const uint64_t v_280 = seed.word(128); + const uint64_t v_281 = seed.word(129); + const uint64_t v_282 = seed.word(130); + const uint64_t v_283 = seed.word(131); + const uint64_t v_284 = seed.word(132); + const uint64_t v_285 = seed.word(133); + const uint64_t v_286 = seed.word(134); + const uint64_t v_287 = seed.word(135); + const uint64_t v_288 = seed.word(136); + const uint64_t v_289 = seed.word(137); + const uint64_t v_290 = seed.word(138); + const uint64_t v_291 = seed.word(139); + const uint64_t v_292 = seed.word(140); + const uint64_t v_293 = seed.word(141); + const uint64_t v_294 = seed.word(142); + const uint64_t v_295 = seed.word(143); + const uint64_t v_296 = seed.word(144); + const uint64_t v_297 = seed.word(145); + row[layout.auxiliaries + 112] = v_266; + row[layout.auxiliaries + 113] = v_267; + row[layout.auxiliaries + 114] = v_268; + row[layout.auxiliaries + 115] = v_269; + row[layout.auxiliaries + 116] = v_270; + row[layout.auxiliaries + 117] = v_271; + row[layout.auxiliaries + 118] = v_272; + row[layout.auxiliaries + 119] = v_273; + row[layout.auxiliaries + 120] = v_274; + row[layout.auxiliaries + 121] = v_275; + row[layout.auxiliaries + 122] = v_276; + row[layout.auxiliaries + 123] = v_277; + row[layout.auxiliaries + 124] = v_278; + row[layout.auxiliaries + 125] = v_279; + row[layout.auxiliaries + 126] = v_280; + row[layout.auxiliaries + 127] = v_281; + row[layout.auxiliaries + 128] = v_282; + row[layout.auxiliaries + 129] = v_283; + row[layout.auxiliaries + 130] = v_284; + row[layout.auxiliaries + 131] = v_285; + row[layout.auxiliaries + 132] = v_286; + row[layout.auxiliaries + 133] = v_287; + row[layout.auxiliaries + 134] = v_288; + row[layout.auxiliaries + 135] = v_289; + row[layout.auxiliaries + 136] = v_290; + row[layout.auxiliaries + 137] = v_291; + row[layout.auxiliaries + 138] = v_292; + row[layout.auxiliaries + 139] = v_293; + row[layout.auxiliaries + 140] = v_294; + row[layout.auxiliaries + 141] = v_295; + row[layout.auxiliaries + 142] = v_296; + row[layout.auxiliaries + 143] = v_297; + const uint64_t v_299 = seed.word(146); + row[layout.auxiliaries + 144] = v_299; + const uint64_t v_301 = seed.word(147); + row[layout.auxiliaries + 145] = v_301; + const uint64_t v_302 = seed.word(148); + row[layout.auxiliaries + 146] = v_302; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_79(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 272 : 1264; + const Seed_multi_stark_79 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_79(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_79(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_79<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_79<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_79(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 153) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 272 : encoding == 0 ? 1264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_79); +} + +__device__ __constant__ uint64_t inverse_83_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_multi_stark_83 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_83(Seed_multi_stark_83 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_83_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_83(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_multi_stark_83 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_83(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_83(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_83<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_83<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_83(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_83); +} + +__device__ __constant__ uint64_t inverse_100_0[] = {0ULL}; +template struct Seed_multi_stark_100 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 176); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u8(data + 276); + case 7: return load_u8(data + 277); + case 8: return load_u8(data + 278); + case 9: return load_u8(data + 279); + case 10: return load_u8(data + 280); + case 11: return load_u8(data + 281); + case 12: return load_u32(data + 180); + case 13: return load_u64(data + 40); + case 14: return load_u64(data + 48); + case 15: return load_u64(data + 56); + case 16: return load_u8(data + 282); + case 17: return load_u8(data + 283); + case 18: return load_u8(data + 284); + case 19: return load_u8(data + 285); + case 20: return load_u8(data + 286); + case 21: return load_u8(data + 287); + case 22: return load_u32(data + 184); + case 23: return load_u64(data + 64); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u64(data + 88); + case 27: return load_u64(data + 96); + case 28: return load_u8(data + 288); + case 29: return load_u8(data + 289); + case 30: return load_u8(data + 290); + case 31: return load_u8(data + 291); + case 32: return load_u32(data + 188); + case 33: return load_u64(data + 104); + case 34: return load_u64(data + 112); + case 35: return load_u64(data + 120); + case 36: return load_u8(data + 292); + case 37: return load_u8(data + 293); + case 38: return load_u8(data + 294); + case 39: return load_u8(data + 295); + case 40: return load_u8(data + 296); + case 41: return load_u8(data + 297); + case 42: return load_u32(data + 192); + case 43: return load_u64(data + 128); + case 44: return load_u32(data + 196); + case 45: return load_u64(data + 136); + case 46: return load_u32(data + 200); + case 47: return load_u32(data + 204); + case 48: return load_u32(data + 208); + case 49: return load_u64(data + 144); + case 50: return load_u32(data + 212); + case 51: return load_u32(data + 216); + case 52: return load_u32(data + 220); + case 53: return load_u64(data + 152); + case 54: return load_u32(data + 224); + case 55: return load_u32(data + 228); + case 56: return load_u32(data + 232); + case 57: return load_u64(data + 160); + case 58: return load_u32(data + 236); + case 59: return load_u32(data + 240); + case 60: return load_u64(data + 168); + case 61: return load_u32(data + 244); + case 62: return load_u32(data + 248); + case 63: return load_u32(data + 252); + case 64: return load_u32(data + 256); + case 65: return load_u32(data + 260); + case 66: return load_u32(data + 264); + case 67: return load_u32(data + 268); + case 68: return load_u32(data + 272); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_100(Seed_multi_stark_100 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 2] = v_4; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_100_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_5 = seed.word(3); + const uint64_t v_6 = seed.word(4); + const uint64_t v_7 = seed.word(5); + const uint64_t v_8 = seed.word(6); + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + row[layout.auxiliaries + 2] = v_5; + row[layout.auxiliaries + 3] = v_6; + row[layout.auxiliaries + 4] = v_7; + row[layout.auxiliaries + 5] = v_8; + row[layout.auxiliaries + 6] = v_9; + row[layout.auxiliaries + 7] = v_10; + row[layout.auxiliaries + 8] = v_11; + row[layout.auxiliaries + 9] = v_12; + row[layout.auxiliaries + 10] = v_13; + row[layout.auxiliaries + 11] = v_14; + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + const uint64_t v_23 = seed.word(21); + const uint64_t v_24 = seed.word(22); + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.auxiliaries + 14] = v_17; + row[layout.auxiliaries + 15] = v_18; + row[layout.auxiliaries + 16] = v_19; + row[layout.auxiliaries + 17] = v_20; + row[layout.auxiliaries + 18] = v_21; + row[layout.auxiliaries + 19] = v_22; + row[layout.auxiliaries + 20] = v_23; + row[layout.auxiliaries + 21] = v_24; + const uint64_t v_25 = seed.word(23); + const uint64_t v_26 = seed.word(24); + const uint64_t v_27 = seed.word(25); + const uint64_t v_28 = seed.word(26); + const uint64_t v_29 = seed.word(27); + const uint64_t v_30 = seed.word(28); + const uint64_t v_31 = seed.word(29); + const uint64_t v_32 = seed.word(30); + const uint64_t v_33 = seed.word(31); + const uint64_t v_34 = seed.word(32); + row[layout.auxiliaries + 22] = v_25; + row[layout.auxiliaries + 23] = v_26; + row[layout.auxiliaries + 24] = v_27; + row[layout.auxiliaries + 25] = v_28; + row[layout.auxiliaries + 26] = v_29; + row[layout.auxiliaries + 27] = v_30; + row[layout.auxiliaries + 28] = v_31; + row[layout.auxiliaries + 29] = v_32; + row[layout.auxiliaries + 30] = v_33; + row[layout.auxiliaries + 31] = v_34; + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + const uint64_t v_44 = seed.word(42); + row[layout.auxiliaries + 32] = v_35; + row[layout.auxiliaries + 33] = v_36; + row[layout.auxiliaries + 34] = v_37; + row[layout.auxiliaries + 35] = v_38; + row[layout.auxiliaries + 36] = v_39; + row[layout.auxiliaries + 37] = v_40; + row[layout.auxiliaries + 38] = v_41; + row[layout.auxiliaries + 39] = v_42; + row[layout.auxiliaries + 40] = v_43; + row[layout.auxiliaries + 41] = v_44; + const uint64_t v_45 = seed.word(43); + const uint64_t v_46 = seed.word(44); + row[layout.auxiliaries + 42] = v_45; + row[layout.auxiliaries + 43] = v_46; + const uint64_t v_47 = seed.word(45); + const uint64_t v_48 = seed.word(46); + row[layout.auxiliaries + 44] = v_47; + row[layout.auxiliaries + 45] = v_48; + const uint64_t v_50 = seed.word(47); + const uint64_t v_51 = seed.word(48); + row[layout.auxiliaries + 46] = v_50; + row[layout.auxiliaries + 47] = v_51; + const uint64_t v_52 = seed.word(49); + const uint64_t v_53 = seed.word(50); + row[layout.auxiliaries + 48] = v_52; + row[layout.auxiliaries + 49] = v_53; + const uint64_t v_54 = seed.word(51); + const uint64_t v_55 = seed.word(52); + row[layout.auxiliaries + 50] = v_54; + row[layout.auxiliaries + 51] = v_55; + const uint64_t v_56 = seed.word(53); + const uint64_t v_57 = seed.word(54); + row[layout.auxiliaries + 52] = v_56; + row[layout.auxiliaries + 53] = v_57; + const uint64_t v_58 = seed.word(55); + const uint64_t v_59 = seed.word(56); + row[layout.auxiliaries + 54] = v_58; + row[layout.auxiliaries + 55] = v_59; + const uint64_t v_60 = seed.word(57); + row[layout.auxiliaries + 56] = v_60; + const uint64_t v_61 = uint64_t(v_60 == 0); + row[layout.auxiliaries + 57] = inverse(v_60); + row[layout.auxiliaries + 58] = v_61; + const uint64_t v_62 = goldilocks_add(v_60, v_61); + const uint64_t v_63 = goldilocks_add(v_62, v_62); + const uint64_t v_64 = goldilocks_add(v_52, v_63); + const uint64_t v_65 = ((v_64 >> 0) & 255ULL); + const uint64_t v_66 = ((v_64 >> 8) & 255ULL); + const uint64_t v_67 = ((v_64 >> 16) & 255ULL); + const uint64_t v_68 = ((v_64 >> 24) & 255ULL); + const uint64_t v_69 = ((v_64 >> 32) & 255ULL); + const uint64_t v_70 = ((v_64 >> 40) & 255ULL); + const uint64_t v_71 = ((v_64 >> 48) & 255ULL); + const uint64_t v_72 = ((v_64 >> 56) & 255ULL); + row[layout.auxiliaries + 59] = v_65; + row[layout.auxiliaries + 60] = v_66; + row[layout.auxiliaries + 61] = v_67; + row[layout.auxiliaries + 62] = v_68; + row[layout.auxiliaries + 63] = v_69; + row[layout.auxiliaries + 64] = v_70; + row[layout.auxiliaries + 65] = v_71; + row[layout.auxiliaries + 66] = v_72; + const uint64_t v_94 = 1020ULL; + const uint64_t v_95 = goldilocks_sub(v_72, v_94); + const uint64_t v_96 = goldilocks_add(v_71, v_95); + const uint64_t v_97 = goldilocks_add(v_70, v_96); + const uint64_t v_98 = goldilocks_add(v_69, v_97); + const uint64_t v_99 = uint64_t(v_98 == 0); + row[layout.auxiliaries + 67] = inverse(v_98); + row[layout.auxiliaries + 68] = v_99; + const uint64_t v_100 = goldilocks_add(v_67, v_68); + const uint64_t v_101 = goldilocks_add(v_66, v_100); + const uint64_t v_102 = goldilocks_add(v_65, v_101); + const uint64_t v_103 = uint64_t(v_102 == 0); + row[layout.auxiliaries + 69] = inverse(v_102); + row[layout.auxiliaries + 70] = v_103; + const uint64_t v_104 = 1ULL; + const uint64_t v_105 = goldilocks_sub(v_104, v_103); + const uint64_t v_106 = goldilocks_mul(v_99, v_105); + row[layout.auxiliaries + 71] = v_106; + const uint64_t v_108 = ((v_63 >> 0) & 255ULL); + const uint64_t v_109 = ((v_63 >> 8) & 255ULL); + const uint64_t v_110 = ((v_63 >> 16) & 255ULL); + const uint64_t v_111 = ((v_63 >> 24) & 255ULL); + const uint64_t v_112 = ((v_63 >> 32) & 255ULL); + const uint64_t v_113 = ((v_63 >> 40) & 255ULL); + const uint64_t v_114 = ((v_63 >> 48) & 255ULL); + const uint64_t v_115 = ((v_63 >> 56) & 255ULL); + row[layout.auxiliaries + 72] = v_108; + row[layout.auxiliaries + 73] = v_109; + row[layout.auxiliaries + 74] = v_110; + row[layout.auxiliaries + 75] = v_111; + row[layout.auxiliaries + 76] = v_112; + row[layout.auxiliaries + 77] = v_113; + row[layout.auxiliaries + 78] = v_114; + row[layout.auxiliaries + 79] = v_115; + const uint64_t v_130 = goldilocks_sub(v_115, v_94); + const uint64_t v_131 = goldilocks_add(v_114, v_130); + const uint64_t v_132 = goldilocks_add(v_113, v_131); + const uint64_t v_133 = goldilocks_add(v_112, v_132); + const uint64_t v_134 = uint64_t(v_133 == 0); + row[layout.auxiliaries + 80] = inverse(v_133); + row[layout.auxiliaries + 81] = v_134; + const uint64_t v_135 = goldilocks_add(v_110, v_111); + const uint64_t v_136 = goldilocks_add(v_109, v_135); + const uint64_t v_137 = goldilocks_add(v_108, v_136); + const uint64_t v_138 = uint64_t(v_137 == 0); + row[layout.auxiliaries + 82] = inverse(v_137); + row[layout.auxiliaries + 83] = v_138; + const uint64_t v_139 = goldilocks_sub(v_104, v_138); + const uint64_t v_140 = goldilocks_mul(v_134, v_139); + row[layout.auxiliaries + 84] = v_140; + const uint64_t v_142 = ((v_45 >> 0) & 255ULL); + const uint64_t v_143 = ((v_45 >> 8) & 255ULL); + const uint64_t v_144 = ((v_45 >> 16) & 255ULL); + const uint64_t v_145 = ((v_45 >> 24) & 255ULL); + const uint64_t v_146 = ((v_45 >> 32) & 255ULL); + const uint64_t v_147 = ((v_45 >> 40) & 255ULL); + const uint64_t v_148 = ((v_45 >> 48) & 255ULL); + const uint64_t v_149 = ((v_45 >> 56) & 255ULL); + row[layout.auxiliaries + 85] = v_142; + row[layout.auxiliaries + 86] = v_143; + row[layout.auxiliaries + 87] = v_144; + row[layout.auxiliaries + 88] = v_145; + row[layout.auxiliaries + 89] = v_146; + row[layout.auxiliaries + 90] = v_147; + row[layout.auxiliaries + 91] = v_148; + row[layout.auxiliaries + 92] = v_149; + const uint64_t v_164 = goldilocks_sub(v_149, v_94); + const uint64_t v_165 = goldilocks_add(v_148, v_164); + const uint64_t v_166 = goldilocks_add(v_147, v_165); + const uint64_t v_167 = goldilocks_add(v_146, v_166); + const uint64_t v_168 = uint64_t(v_167 == 0); + row[layout.auxiliaries + 93] = inverse(v_167); + row[layout.auxiliaries + 94] = v_168; + const uint64_t v_169 = goldilocks_add(v_144, v_145); + const uint64_t v_170 = goldilocks_add(v_143, v_169); + const uint64_t v_171 = goldilocks_add(v_142, v_170); + const uint64_t v_172 = uint64_t(v_171 == 0); + row[layout.auxiliaries + 95] = inverse(v_171); + row[layout.auxiliaries + 96] = v_172; + const uint64_t v_173 = goldilocks_sub(v_104, v_172); + const uint64_t v_174 = goldilocks_mul(v_168, v_173); + row[layout.auxiliaries + 97] = v_174; + const uint64_t v_177 = seed.word(58); + const uint64_t v_178 = seed.word(59); + const uint64_t v_179 = seed.word(60); + row[layout.auxiliaries + 98] = v_177; + row[layout.auxiliaries + 99] = v_178; + row[layout.auxiliaries + 100] = v_179; + const uint64_t v_180 = seed.word(61); + row[layout.auxiliaries + 101] = v_180; + const uint64_t v_181 = seed.word(62); + row[layout.auxiliaries + 102] = v_181; + const uint64_t v_182 = seed.word(63); + row[layout.auxiliaries + 103] = v_182; + const uint64_t v_183 = seed.word(64); + row[layout.auxiliaries + 104] = v_183; + const uint64_t v_184 = seed.word(65); + row[layout.auxiliaries + 105] = v_184; + const uint64_t v_185 = seed.word(66); + row[layout.auxiliaries + 106] = v_185; + const uint64_t v_186 = seed.word(67); + row[layout.auxiliaries + 107] = v_186; + const uint64_t v_187 = seed.word(68); + row[layout.auxiliaries + 108] = v_187; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_100(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 304 : 552; + const Seed_multi_stark_100 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_100(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_100(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_100<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_100<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_100(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 109) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 304 : encoding == 0 ? 552 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_100); +} + +__device__ __constant__ uint64_t inverse_114_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_3[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_4[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_5[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_6[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_7[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_8[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_10[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_114_11[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_114_12[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_114_13[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_multi_stark_114 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 312); + case 2: return load_u32(data + 316); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 320); + case 5: return load_u32(data + 324); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 404); + case 8: return load_u8(data + 405); + case 9: return load_u8(data + 406); + case 10: return load_u8(data + 407); + case 11: return load_u8(data + 408); + case 12: return load_u8(data + 409); + case 13: return load_u8(data + 410); + case 14: return load_u8(data + 411); + case 15: return load_u32(data + 328); + case 16: return load_u32(data + 332); + case 17: return load_u8(data + 412); + case 18: return load_u64(data + 24); + case 19: return load_u64(data + 32); + case 20: return load_u64(data + 40); + case 21: return load_u64(data + 48); + case 22: return load_u64(data + 56); + case 23: return load_u64(data + 64); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u32(data + 336); + case 27: return load_u32(data + 340); + case 28: return load_u8(data + 413); + case 29: return load_u8(data + 414); + case 30: return load_u8(data + 415); + case 31: return load_u8(data + 416); + case 32: return load_u8(data + 417); + case 33: return load_u8(data + 418); + case 34: return load_u8(data + 419); + case 35: return load_u8(data + 420); + case 36: return load_u8(data + 421); + case 37: return load_u32(data + 344); + case 38: return load_u32(data + 348); + case 39: return load_u8(data + 422); + case 40: return load_u8(data + 423); + case 41: return load_u8(data + 424); + case 42: return load_u8(data + 425); + case 43: return load_u8(data + 426); + case 44: return load_u8(data + 427); + case 45: return load_u8(data + 428); + case 46: return load_u8(data + 429); + case 47: return load_u8(data + 430); + case 48: return load_u32(data + 352); + case 49: return load_u32(data + 356); + case 50: return load_u8(data + 431); + case 51: return load_u8(data + 432); + case 52: return load_u8(data + 433); + case 53: return load_u8(data + 434); + case 54: return load_u8(data + 435); + case 55: return load_u8(data + 436); + case 56: return load_u8(data + 437); + case 57: return load_u8(data + 438); + case 58: return load_u8(data + 439); + case 59: return load_u32(data + 360); + case 60: return load_u32(data + 364); + case 61: return load_u8(data + 440); + case 62: return load_u8(data + 441); + case 63: return load_u8(data + 442); + case 64: return load_u8(data + 443); + case 65: return load_u8(data + 444); + case 66: return load_u8(data + 445); + case 67: return load_u8(data + 446); + case 68: return load_u8(data + 447); + case 69: return load_u8(data + 448); + case 70: return load_u32(data + 368); + case 71: return load_u32(data + 372); + case 72: return load_u8(data + 449); + case 73: return load_u8(data + 450); + case 74: return load_u8(data + 451); + case 75: return load_u8(data + 452); + case 76: return load_u8(data + 453); + case 77: return load_u8(data + 454); + case 78: return load_u8(data + 455); + case 79: return load_u8(data + 456); + case 80: return load_u8(data + 457); + case 81: return load_u32(data + 376); + case 82: return load_u32(data + 380); + case 83: return load_u8(data + 458); + case 84: return load_u8(data + 459); + case 85: return load_u8(data + 460); + case 86: return load_u8(data + 461); + case 87: return load_u8(data + 462); + case 88: return load_u8(data + 463); + case 89: return load_u8(data + 464); + case 90: return load_u8(data + 465); + case 91: return load_u8(data + 466); + case 92: return load_u32(data + 384); + case 93: return load_u32(data + 388); + case 94: return load_u8(data + 467); + case 95: return load_u8(data + 468); + case 96: return load_u64(data + 88); + case 97: return load_u64(data + 96); + case 98: return load_u64(data + 104); + case 99: return load_u64(data + 112); + case 100: return load_u64(data + 120); + case 101: return load_u64(data + 128); + case 102: return load_u64(data + 136); + case 103: return load_u64(data + 144); + case 104: return load_u64(data + 152); + case 105: return load_u8(data + 469); + case 106: return load_u64(data + 160); + case 107: return load_u64(data + 168); + case 108: return load_u8(data + 470); + case 109: return load_u8(data + 471); + case 110: return load_u8(data + 472); + case 111: return load_u8(data + 473); + case 112: return load_u8(data + 474); + case 113: return load_u8(data + 475); + case 114: return load_u8(data + 476); + case 115: return load_u8(data + 477); + case 116: return load_u8(data + 478); + case 117: return load_u8(data + 479); + case 118: return load_u8(data + 480); + case 119: return load_u8(data + 481); + case 120: return load_u8(data + 482); + case 121: return load_u8(data + 483); + case 122: return load_u8(data + 484); + case 123: return load_u8(data + 485); + case 124: return load_u8(data + 486); + case 125: return load_u8(data + 487); + case 126: return load_u8(data + 488); + case 127: return load_u8(data + 489); + case 128: return load_u8(data + 490); + case 129: return load_u8(data + 491); + case 130: return load_u8(data + 492); + case 131: return load_u8(data + 493); + case 132: return load_u8(data + 494); + case 133: return load_u8(data + 495); + case 134: return load_u8(data + 496); + case 135: return load_u8(data + 497); + case 136: return load_u8(data + 498); + case 137: return load_u8(data + 499); + case 138: return load_u8(data + 500); + case 139: return load_u8(data + 501); + case 140: return load_u8(data + 502); + case 141: return load_u8(data + 503); + case 142: return load_u8(data + 504); + case 143: return load_u8(data + 505); + case 144: return load_u8(data + 506); + case 145: return load_u8(data + 507); + case 146: return load_u8(data + 508); + case 147: return load_u8(data + 509); + case 148: return load_u8(data + 510); + case 149: return load_u8(data + 511); + case 150: return load_u8(data + 512); + case 151: return load_u8(data + 513); + case 152: return load_u8(data + 514); + case 153: return load_u8(data + 515); + case 154: return load_u8(data + 516); + case 155: return load_u8(data + 517); + case 156: return load_u8(data + 518); + case 157: return load_u8(data + 519); + case 158: return load_u8(data + 520); + case 159: return load_u8(data + 521); + case 160: return load_u8(data + 522); + case 161: return load_u8(data + 523); + case 162: return load_u8(data + 524); + case 163: return load_u8(data + 525); + case 164: return load_u8(data + 526); + case 165: return load_u8(data + 527); + case 166: return load_u8(data + 528); + case 167: return load_u8(data + 529); + case 168: return load_u8(data + 530); + case 169: return load_u8(data + 531); + case 170: return load_u8(data + 532); + case 171: return load_u8(data + 533); + case 172: return load_u8(data + 534); + case 173: return load_u8(data + 535); + case 174: return load_u8(data + 536); + case 175: return load_u8(data + 537); + case 176: return load_u8(data + 538); + case 177: return load_u8(data + 539); + case 178: return load_u8(data + 540); + case 179: return load_u8(data + 541); + case 180: return load_u8(data + 542); + case 181: return load_u64(data + 176); + case 182: return load_u64(data + 184); + case 183: return load_u64(data + 192); + case 184: return load_u64(data + 200); + case 185: return load_u64(data + 208); + case 186: return load_u64(data + 216); + case 187: return load_u64(data + 224); + case 188: return load_u64(data + 232); + case 189: return load_u64(data + 240); + case 190: return load_u64(data + 248); + case 191: return load_u64(data + 256); + case 192: return load_u64(data + 264); + case 193: return load_u64(data + 272); + case 194: return load_u64(data + 280); + case 195: return load_u64(data + 288); + case 196: return load_u64(data + 296); + case 197: return load_u32(data + 392); + case 198: return load_u32(data + 396); + case 199: return load_u32(data + 400); + case 200: return load_u64(data + 304); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_114(Seed_multi_stark_114 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + row[layout.auxiliaries + 1] = v_6; + row[layout.auxiliaries + 2] = v_7; + row[layout.auxiliaries + 3] = v_8; + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.auxiliaries + 7] = v_12; + row[layout.auxiliaries + 8] = v_13; + row[layout.auxiliaries + 9] = v_14; + row[layout.auxiliaries + 10] = v_15; + row[layout.auxiliaries + 11] = v_16; + switch (v_16) { + case 0ULL: { + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 12] = v_17; + row[layout.auxiliaries + 13] = v_18; + row[layout.auxiliaries + 14] = v_19; + row[layout.auxiliaries + 15] = v_20; + row[layout.auxiliaries + 16] = v_21; + row[layout.auxiliaries + 17] = v_22; + row[layout.auxiliaries + 18] = v_23; + row[layout.auxiliaries + 19] = v_24; + switch (v_17) { + case 0ULL: { + switch (v_18) { + case 0ULL: { + switch (v_19) { + case 0ULL: { + switch (v_20) { + case 0ULL: { + switch (v_21) { + case 0ULL: { + switch (v_22) { + case 0ULL: { + switch (v_23) { + case 0ULL: { + switch (v_24) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + row[layout.auxiliaries + 20] = v_25; + row[layout.auxiliaries + 21] = v_26; + row[layout.auxiliaries + 22] = v_27; + row[layout.auxiliaries + 23] = v_28; + row[layout.auxiliaries + 24] = v_29; + row[layout.auxiliaries + 25] = v_30; + row[layout.auxiliaries + 26] = v_31; + row[layout.auxiliaries + 27] = v_32; + row[layout.auxiliaries + 28] = v_33; + row[layout.auxiliaries + 29] = v_34; + row[layout.auxiliaries + 30] = v_35; + row[layout.auxiliaries + 31] = v_36; + row[layout.auxiliaries + 32] = v_37; + row[layout.auxiliaries + 33] = v_38; + row[layout.auxiliaries + 34] = v_39; + row[layout.auxiliaries + 35] = v_40; + row[layout.auxiliaries + 36] = v_41; + row[layout.auxiliaries + 37] = v_42; + row[layout.auxiliaries + 38] = v_43; + row[layout.auxiliaries + 39] = v_44; + row[layout.auxiliaries + 40] = v_45; + row[layout.auxiliaries + 41] = v_46; + row[layout.auxiliaries + 42] = v_47; + row[layout.auxiliaries + 43] = v_48; + row[layout.auxiliaries + 44] = v_49; + row[layout.auxiliaries + 45] = v_50; + row[layout.auxiliaries + 46] = v_51; + row[layout.auxiliaries + 47] = v_52; + row[layout.auxiliaries + 48] = v_53; + row[layout.auxiliaries + 49] = v_54; + row[layout.auxiliaries + 50] = v_55; + row[layout.auxiliaries + 51] = v_56; + const uint64_t v_58 = seed.word(58); + const uint64_t v_59 = seed.word(59); + const uint64_t v_60 = seed.word(60); + const uint64_t v_61 = seed.word(61); + const uint64_t v_62 = seed.word(62); + const uint64_t v_63 = seed.word(63); + const uint64_t v_64 = seed.word(64); + const uint64_t v_65 = seed.word(65); + row[layout.auxiliaries + 52] = v_58; + row[layout.auxiliaries + 53] = v_59; + row[layout.auxiliaries + 54] = v_60; + row[layout.auxiliaries + 55] = v_61; + row[layout.auxiliaries + 56] = v_62; + row[layout.auxiliaries + 57] = v_63; + row[layout.auxiliaries + 58] = v_64; + row[layout.auxiliaries + 59] = v_65; + const uint64_t v_82 = seed.word(66); + const uint64_t v_83 = seed.word(67); + const uint64_t v_84 = seed.word(68); + const uint64_t v_85 = seed.word(69); + const uint64_t v_86 = seed.word(70); + const uint64_t v_87 = seed.word(71); + const uint64_t v_88 = seed.word(72); + const uint64_t v_89 = seed.word(73); + const uint64_t v_90 = seed.word(74); + const uint64_t v_91 = seed.word(75); + const uint64_t v_92 = seed.word(76); + const uint64_t v_93 = seed.word(77); + const uint64_t v_94 = seed.word(78); + const uint64_t v_95 = seed.word(79); + const uint64_t v_96 = seed.word(80); + const uint64_t v_97 = seed.word(81); + const uint64_t v_98 = seed.word(82); + const uint64_t v_99 = seed.word(83); + const uint64_t v_100 = seed.word(84); + const uint64_t v_101 = seed.word(85); + const uint64_t v_102 = seed.word(86); + const uint64_t v_103 = seed.word(87); + const uint64_t v_104 = seed.word(88); + const uint64_t v_105 = seed.word(89); + const uint64_t v_106 = seed.word(90); + const uint64_t v_107 = seed.word(91); + const uint64_t v_108 = seed.word(92); + const uint64_t v_109 = seed.word(93); + const uint64_t v_110 = seed.word(94); + const uint64_t v_111 = seed.word(95); + const uint64_t v_112 = seed.word(96); + const uint64_t v_113 = seed.word(97); + row[layout.auxiliaries + 60] = v_82; + row[layout.auxiliaries + 61] = v_83; + row[layout.auxiliaries + 62] = v_84; + row[layout.auxiliaries + 63] = v_85; + row[layout.auxiliaries + 64] = v_86; + row[layout.auxiliaries + 65] = v_87; + row[layout.auxiliaries + 66] = v_88; + row[layout.auxiliaries + 67] = v_89; + row[layout.auxiliaries + 68] = v_90; + row[layout.auxiliaries + 69] = v_91; + row[layout.auxiliaries + 70] = v_92; + row[layout.auxiliaries + 71] = v_93; + row[layout.auxiliaries + 72] = v_94; + row[layout.auxiliaries + 73] = v_95; + row[layout.auxiliaries + 74] = v_96; + row[layout.auxiliaries + 75] = v_97; + row[layout.auxiliaries + 76] = v_98; + row[layout.auxiliaries + 77] = v_99; + row[layout.auxiliaries + 78] = v_100; + row[layout.auxiliaries + 79] = v_101; + row[layout.auxiliaries + 80] = v_102; + row[layout.auxiliaries + 81] = v_103; + row[layout.auxiliaries + 82] = v_104; + row[layout.auxiliaries + 83] = v_105; + row[layout.auxiliaries + 84] = v_106; + row[layout.auxiliaries + 85] = v_107; + row[layout.auxiliaries + 86] = v_108; + row[layout.auxiliaries + 87] = v_109; + row[layout.auxiliaries + 88] = v_110; + row[layout.auxiliaries + 89] = v_111; + row[layout.auxiliaries + 90] = v_112; + row[layout.auxiliaries + 91] = v_113; + const uint64_t v_114 = seed.word(98); + row[layout.auxiliaries + 92] = v_114; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 20] = (v_24 <= 0ULL ? inverse_114_0[v_24] : inverse(goldilocks_sub(v_24, 0ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_23 <= 0ULL ? inverse_114_1[v_23] : inverse(goldilocks_sub(v_23, 0ULL))); + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_22 <= 0ULL ? inverse_114_2[v_22] : inverse(goldilocks_sub(v_22, 0ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_21 <= 0ULL ? inverse_114_3[v_21] : inverse(goldilocks_sub(v_21, 0ULL))); + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_20 <= 0ULL ? inverse_114_4[v_20] : inverse(goldilocks_sub(v_20, 0ULL))); + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_19 <= 0ULL ? inverse_114_5[v_19] : inverse(goldilocks_sub(v_19, 0ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_18 <= 0ULL ? inverse_114_6[v_18] : inverse(goldilocks_sub(v_18, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_17 <= 0ULL ? inverse_114_7[v_17] : inverse(goldilocks_sub(v_17, 0ULL))); + row[layout.selectors + 8] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 12] = (v_16 <= 0ULL ? inverse_114_8[v_16] : inverse(goldilocks_sub(v_16, 0ULL))); + const uint64_t v_115 = seed.word(18); + const uint64_t v_116 = seed.word(19); + const uint64_t v_117 = seed.word(20); + const uint64_t v_118 = seed.word(21); + const uint64_t v_119 = seed.word(22); + const uint64_t v_120 = seed.word(23); + const uint64_t v_121 = seed.word(24); + const uint64_t v_122 = seed.word(25); + const uint64_t v_123 = seed.word(26); + const uint64_t v_124 = seed.word(27); + const uint64_t v_125 = seed.word(28); + row[layout.auxiliaries + 13] = v_115; + row[layout.auxiliaries + 14] = v_116; + row[layout.auxiliaries + 15] = v_117; + row[layout.auxiliaries + 16] = v_118; + row[layout.auxiliaries + 17] = v_119; + row[layout.auxiliaries + 18] = v_120; + row[layout.auxiliaries + 19] = v_121; + row[layout.auxiliaries + 20] = v_122; + row[layout.auxiliaries + 21] = v_123; + row[layout.auxiliaries + 22] = v_124; + row[layout.auxiliaries + 23] = v_125; + const uint64_t v_126 = seed.word(29); + const uint64_t v_127 = seed.word(30); + const uint64_t v_128 = seed.word(31); + const uint64_t v_129 = seed.word(32); + const uint64_t v_130 = seed.word(33); + const uint64_t v_131 = seed.word(34); + const uint64_t v_132 = seed.word(35); + const uint64_t v_133 = seed.word(36); + const uint64_t v_134 = seed.word(37); + const uint64_t v_135 = seed.word(38); + const uint64_t v_136 = seed.word(39); + row[layout.auxiliaries + 24] = v_126; + row[layout.auxiliaries + 25] = v_127; + row[layout.auxiliaries + 26] = v_128; + row[layout.auxiliaries + 27] = v_129; + row[layout.auxiliaries + 28] = v_130; + row[layout.auxiliaries + 29] = v_131; + row[layout.auxiliaries + 30] = v_132; + row[layout.auxiliaries + 31] = v_133; + row[layout.auxiliaries + 32] = v_134; + row[layout.auxiliaries + 33] = v_135; + row[layout.auxiliaries + 34] = v_136; + const uint64_t v_137 = seed.word(40); + const uint64_t v_138 = seed.word(41); + const uint64_t v_139 = seed.word(42); + const uint64_t v_140 = seed.word(43); + const uint64_t v_141 = seed.word(44); + const uint64_t v_142 = seed.word(45); + const uint64_t v_143 = seed.word(46); + const uint64_t v_144 = seed.word(47); + const uint64_t v_145 = seed.word(48); + const uint64_t v_146 = seed.word(49); + const uint64_t v_147 = seed.word(50); + row[layout.auxiliaries + 35] = v_137; + row[layout.auxiliaries + 36] = v_138; + row[layout.auxiliaries + 37] = v_139; + row[layout.auxiliaries + 38] = v_140; + row[layout.auxiliaries + 39] = v_141; + row[layout.auxiliaries + 40] = v_142; + row[layout.auxiliaries + 41] = v_143; + row[layout.auxiliaries + 42] = v_144; + row[layout.auxiliaries + 43] = v_145; + row[layout.auxiliaries + 44] = v_146; + row[layout.auxiliaries + 45] = v_147; + const uint64_t v_148 = seed.word(51); + const uint64_t v_149 = seed.word(52); + const uint64_t v_150 = seed.word(53); + const uint64_t v_151 = seed.word(54); + const uint64_t v_152 = seed.word(55); + const uint64_t v_153 = seed.word(56); + const uint64_t v_154 = seed.word(57); + const uint64_t v_155 = seed.word(58); + const uint64_t v_156 = seed.word(59); + const uint64_t v_157 = seed.word(60); + const uint64_t v_158 = seed.word(61); + row[layout.auxiliaries + 46] = v_148; + row[layout.auxiliaries + 47] = v_149; + row[layout.auxiliaries + 48] = v_150; + row[layout.auxiliaries + 49] = v_151; + row[layout.auxiliaries + 50] = v_152; + row[layout.auxiliaries + 51] = v_153; + row[layout.auxiliaries + 52] = v_154; + row[layout.auxiliaries + 53] = v_155; + row[layout.auxiliaries + 54] = v_156; + row[layout.auxiliaries + 55] = v_157; + row[layout.auxiliaries + 56] = v_158; + const uint64_t v_159 = seed.word(62); + const uint64_t v_160 = seed.word(63); + const uint64_t v_161 = seed.word(64); + const uint64_t v_162 = seed.word(65); + const uint64_t v_163 = seed.word(66); + const uint64_t v_164 = seed.word(67); + const uint64_t v_165 = seed.word(68); + const uint64_t v_166 = seed.word(69); + const uint64_t v_167 = seed.word(70); + const uint64_t v_168 = seed.word(71); + const uint64_t v_169 = seed.word(72); + row[layout.auxiliaries + 57] = v_159; + row[layout.auxiliaries + 58] = v_160; + row[layout.auxiliaries + 59] = v_161; + row[layout.auxiliaries + 60] = v_162; + row[layout.auxiliaries + 61] = v_163; + row[layout.auxiliaries + 62] = v_164; + row[layout.auxiliaries + 63] = v_165; + row[layout.auxiliaries + 64] = v_166; + row[layout.auxiliaries + 65] = v_167; + row[layout.auxiliaries + 66] = v_168; + row[layout.auxiliaries + 67] = v_169; + const uint64_t v_170 = seed.word(73); + const uint64_t v_171 = seed.word(74); + const uint64_t v_172 = seed.word(75); + const uint64_t v_173 = seed.word(76); + const uint64_t v_174 = seed.word(77); + const uint64_t v_175 = seed.word(78); + const uint64_t v_176 = seed.word(79); + const uint64_t v_177 = seed.word(80); + const uint64_t v_178 = seed.word(81); + const uint64_t v_179 = seed.word(82); + const uint64_t v_180 = seed.word(83); + row[layout.auxiliaries + 68] = v_170; + row[layout.auxiliaries + 69] = v_171; + row[layout.auxiliaries + 70] = v_172; + row[layout.auxiliaries + 71] = v_173; + row[layout.auxiliaries + 72] = v_174; + row[layout.auxiliaries + 73] = v_175; + row[layout.auxiliaries + 74] = v_176; + row[layout.auxiliaries + 75] = v_177; + row[layout.auxiliaries + 76] = v_178; + row[layout.auxiliaries + 77] = v_179; + row[layout.auxiliaries + 78] = v_180; + const uint64_t v_181 = seed.word(84); + const uint64_t v_182 = seed.word(85); + const uint64_t v_183 = seed.word(86); + const uint64_t v_184 = seed.word(87); + const uint64_t v_185 = seed.word(88); + const uint64_t v_186 = seed.word(89); + const uint64_t v_187 = seed.word(90); + const uint64_t v_188 = seed.word(91); + const uint64_t v_189 = seed.word(92); + const uint64_t v_190 = seed.word(93); + const uint64_t v_191 = seed.word(94); + row[layout.auxiliaries + 79] = v_181; + row[layout.auxiliaries + 80] = v_182; + row[layout.auxiliaries + 81] = v_183; + row[layout.auxiliaries + 82] = v_184; + row[layout.auxiliaries + 83] = v_185; + row[layout.auxiliaries + 84] = v_186; + row[layout.auxiliaries + 85] = v_187; + row[layout.auxiliaries + 86] = v_188; + row[layout.auxiliaries + 87] = v_189; + row[layout.auxiliaries + 88] = v_190; + row[layout.auxiliaries + 89] = v_191; + const uint64_t v_201 = seed.word(95); + const uint64_t v_202 = seed.word(96); + const uint64_t v_203 = seed.word(97); + const uint64_t v_204 = seed.word(98); + const uint64_t v_205 = seed.word(99); + const uint64_t v_206 = seed.word(100); + const uint64_t v_207 = seed.word(101); + const uint64_t v_208 = seed.word(102); + const uint64_t v_209 = seed.word(103); + const uint64_t v_210 = seed.word(104); + row[layout.auxiliaries + 90] = v_201; + row[layout.auxiliaries + 91] = v_202; + row[layout.auxiliaries + 92] = v_203; + row[layout.auxiliaries + 93] = v_204; + row[layout.auxiliaries + 94] = v_205; + row[layout.auxiliaries + 95] = v_206; + row[layout.auxiliaries + 96] = v_207; + row[layout.auxiliaries + 97] = v_208; + row[layout.auxiliaries + 98] = v_209; + row[layout.auxiliaries + 99] = v_210; + uint64_t v_217; + switch (v_201) { + case 1ULL: { + const uint64_t v_211 = seed.word(105); + const uint64_t v_212 = seed.word(106); + const uint64_t v_213 = seed.word(107); + row[layout.auxiliaries + 100] = v_211; + row[layout.auxiliaries + 101] = v_212; + row[layout.auxiliaries + 102] = v_213; + switch (v_211) { + case 1ULL: { + const uint64_t v_214 = 1ULL; + row[layout.selectors + 9] = 1; + v_217 = v_214; + goto continuation_9; + } + default: { + row[layout.auxiliaries + 103] = (v_211 <= 1ULL ? inverse_114_10[v_211] : inverse(goldilocks_sub(v_211, 1ULL))); + const uint64_t v_215 = 0ULL; + row[layout.selectors + 10] = 1; + v_217 = v_215; + goto continuation_9; + } + } + } + default: { + row[layout.auxiliaries + 100] = (v_201 <= 1ULL ? inverse_114_11[v_201] : inverse(goldilocks_sub(v_201, 1ULL))); + const uint64_t v_216 = 0ULL; + row[layout.selectors + 11] = 1; + v_217 = v_216; + goto continuation_9; + } + } + continuation_9:; + row[layout.auxiliaries + 104] = v_217; + const uint64_t v_218 = 15ULL; + const uint64_t v_219 = goldilocks_sub(v_2, v_218); + const uint64_t v_220 = uint64_t(v_219 == 0); + row[layout.auxiliaries + 105] = inverse(v_219); + row[layout.auxiliaries + 106] = v_220; + const uint64_t v_221 = uint64_t(v_2 == 0); + row[layout.auxiliaries + 107] = inverse(v_2); + row[layout.auxiliaries + 108] = v_221; + const uint64_t v_222 = goldilocks_mul(v_217, v_220); + row[layout.auxiliaries + 109] = v_222; + const uint64_t v_225 = seed.word(108); + const uint64_t v_226 = seed.word(109); + const uint64_t v_227 = seed.word(110); + const uint64_t v_228 = seed.word(111); + const uint64_t v_229 = seed.word(112); + const uint64_t v_230 = seed.word(113); + const uint64_t v_231 = seed.word(114); + const uint64_t v_232 = seed.word(115); + row[layout.auxiliaries + 110] = v_225; + row[layout.auxiliaries + 111] = v_226; + row[layout.auxiliaries + 112] = v_227; + row[layout.auxiliaries + 113] = v_228; + row[layout.auxiliaries + 114] = v_229; + row[layout.auxiliaries + 115] = v_230; + row[layout.auxiliaries + 116] = v_231; + row[layout.auxiliaries + 117] = v_232; + const uint64_t v_233 = seed.word(116); + row[layout.auxiliaries + 118] = v_233; + const uint64_t v_234 = goldilocks_mul(v_217, v_233); + row[layout.auxiliaries + 119] = v_234; + const uint64_t v_241 = seed.word(117); + const uint64_t v_242 = seed.word(118); + const uint64_t v_243 = seed.word(119); + const uint64_t v_244 = seed.word(120); + const uint64_t v_245 = seed.word(121); + const uint64_t v_246 = seed.word(122); + const uint64_t v_247 = seed.word(123); + const uint64_t v_248 = seed.word(124); + const uint64_t v_249 = seed.word(125); + const uint64_t v_250 = seed.word(126); + const uint64_t v_251 = seed.word(127); + const uint64_t v_252 = seed.word(128); + const uint64_t v_253 = seed.word(129); + const uint64_t v_254 = seed.word(130); + const uint64_t v_255 = seed.word(131); + const uint64_t v_256 = seed.word(132); + const uint64_t v_257 = seed.word(133); + const uint64_t v_258 = seed.word(134); + const uint64_t v_259 = seed.word(135); + const uint64_t v_260 = seed.word(136); + const uint64_t v_261 = seed.word(137); + const uint64_t v_262 = seed.word(138); + const uint64_t v_263 = seed.word(139); + const uint64_t v_264 = seed.word(140); + const uint64_t v_265 = seed.word(141); + const uint64_t v_266 = seed.word(142); + const uint64_t v_267 = seed.word(143); + const uint64_t v_268 = seed.word(144); + const uint64_t v_269 = seed.word(145); + const uint64_t v_270 = seed.word(146); + const uint64_t v_271 = seed.word(147); + const uint64_t v_272 = seed.word(148); + row[layout.auxiliaries + 120] = v_241; + row[layout.auxiliaries + 121] = v_242; + row[layout.auxiliaries + 122] = v_243; + row[layout.auxiliaries + 123] = v_244; + row[layout.auxiliaries + 124] = v_245; + row[layout.auxiliaries + 125] = v_246; + row[layout.auxiliaries + 126] = v_247; + row[layout.auxiliaries + 127] = v_248; + row[layout.auxiliaries + 128] = v_249; + row[layout.auxiliaries + 129] = v_250; + row[layout.auxiliaries + 130] = v_251; + row[layout.auxiliaries + 131] = v_252; + row[layout.auxiliaries + 132] = v_253; + row[layout.auxiliaries + 133] = v_254; + row[layout.auxiliaries + 134] = v_255; + row[layout.auxiliaries + 135] = v_256; + row[layout.auxiliaries + 136] = v_257; + row[layout.auxiliaries + 137] = v_258; + row[layout.auxiliaries + 138] = v_259; + row[layout.auxiliaries + 139] = v_260; + row[layout.auxiliaries + 140] = v_261; + row[layout.auxiliaries + 141] = v_262; + row[layout.auxiliaries + 142] = v_263; + row[layout.auxiliaries + 143] = v_264; + row[layout.auxiliaries + 144] = v_265; + row[layout.auxiliaries + 145] = v_266; + row[layout.auxiliaries + 146] = v_267; + row[layout.auxiliaries + 147] = v_268; + row[layout.auxiliaries + 148] = v_269; + row[layout.auxiliaries + 149] = v_270; + row[layout.auxiliaries + 150] = v_271; + row[layout.auxiliaries + 151] = v_272; + const uint64_t v_289 = seed.word(149); + const uint64_t v_290 = seed.word(150); + const uint64_t v_291 = seed.word(151); + const uint64_t v_292 = seed.word(152); + const uint64_t v_293 = seed.word(153); + const uint64_t v_294 = seed.word(154); + const uint64_t v_295 = seed.word(155); + const uint64_t v_296 = seed.word(156); + const uint64_t v_297 = seed.word(157); + const uint64_t v_298 = seed.word(158); + const uint64_t v_299 = seed.word(159); + const uint64_t v_300 = seed.word(160); + const uint64_t v_301 = seed.word(161); + const uint64_t v_302 = seed.word(162); + const uint64_t v_303 = seed.word(163); + const uint64_t v_304 = seed.word(164); + const uint64_t v_305 = seed.word(165); + const uint64_t v_306 = seed.word(166); + const uint64_t v_307 = seed.word(167); + const uint64_t v_308 = seed.word(168); + const uint64_t v_309 = seed.word(169); + const uint64_t v_310 = seed.word(170); + const uint64_t v_311 = seed.word(171); + const uint64_t v_312 = seed.word(172); + const uint64_t v_313 = seed.word(173); + const uint64_t v_314 = seed.word(174); + const uint64_t v_315 = seed.word(175); + const uint64_t v_316 = seed.word(176); + const uint64_t v_317 = seed.word(177); + const uint64_t v_318 = seed.word(178); + const uint64_t v_319 = seed.word(179); + const uint64_t v_320 = seed.word(180); + row[layout.auxiliaries + 152] = v_289; + row[layout.auxiliaries + 153] = v_290; + row[layout.auxiliaries + 154] = v_291; + row[layout.auxiliaries + 155] = v_292; + row[layout.auxiliaries + 156] = v_293; + row[layout.auxiliaries + 157] = v_294; + row[layout.auxiliaries + 158] = v_295; + row[layout.auxiliaries + 159] = v_296; + row[layout.auxiliaries + 160] = v_297; + row[layout.auxiliaries + 161] = v_298; + row[layout.auxiliaries + 162] = v_299; + row[layout.auxiliaries + 163] = v_300; + row[layout.auxiliaries + 164] = v_301; + row[layout.auxiliaries + 165] = v_302; + row[layout.auxiliaries + 166] = v_303; + row[layout.auxiliaries + 167] = v_304; + row[layout.auxiliaries + 168] = v_305; + row[layout.auxiliaries + 169] = v_306; + row[layout.auxiliaries + 170] = v_307; + row[layout.auxiliaries + 171] = v_308; + row[layout.auxiliaries + 172] = v_309; + row[layout.auxiliaries + 173] = v_310; + row[layout.auxiliaries + 174] = v_311; + row[layout.auxiliaries + 175] = v_312; + row[layout.auxiliaries + 176] = v_313; + row[layout.auxiliaries + 177] = v_314; + row[layout.auxiliaries + 178] = v_315; + row[layout.auxiliaries + 179] = v_316; + row[layout.auxiliaries + 180] = v_317; + row[layout.auxiliaries + 181] = v_318; + row[layout.auxiliaries + 182] = v_319; + row[layout.auxiliaries + 183] = v_320; + switch (v_217) { + case 1ULL: { + const uint64_t v_322 = seed.word(181); + row[layout.auxiliaries + 184] = v_322; + row[layout.selectors + 12] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 184] = (v_217 <= 1ULL ? inverse_114_12[v_217] : inverse(goldilocks_sub(v_217, 1ULL))); + switch (v_220) { + case 1ULL: { + const uint64_t v_355 = seed.word(181); + const uint64_t v_356 = seed.word(182); + const uint64_t v_357 = seed.word(183); + const uint64_t v_358 = seed.word(184); + const uint64_t v_359 = seed.word(185); + const uint64_t v_360 = seed.word(186); + const uint64_t v_361 = seed.word(187); + const uint64_t v_362 = seed.word(188); + row[layout.auxiliaries + 185] = v_355; + row[layout.auxiliaries + 186] = v_356; + row[layout.auxiliaries + 187] = v_357; + row[layout.auxiliaries + 188] = v_358; + row[layout.auxiliaries + 189] = v_359; + row[layout.auxiliaries + 190] = v_360; + row[layout.auxiliaries + 191] = v_361; + row[layout.auxiliaries + 192] = v_362; + const uint64_t v_363 = seed.word(189); + const uint64_t v_364 = seed.word(190); + const uint64_t v_365 = seed.word(191); + const uint64_t v_366 = seed.word(192); + const uint64_t v_367 = seed.word(193); + const uint64_t v_368 = seed.word(194); + const uint64_t v_369 = seed.word(195); + const uint64_t v_370 = seed.word(196); + row[layout.auxiliaries + 193] = v_363; + row[layout.auxiliaries + 194] = v_364; + row[layout.auxiliaries + 195] = v_365; + row[layout.auxiliaries + 196] = v_366; + row[layout.auxiliaries + 197] = v_367; + row[layout.auxiliaries + 198] = v_368; + row[layout.auxiliaries + 199] = v_369; + row[layout.auxiliaries + 200] = v_370; + const uint64_t v_371 = seed.word(197); + row[layout.auxiliaries + 201] = v_371; + const uint64_t v_372 = seed.word(198); + row[layout.auxiliaries + 202] = v_372; + const uint64_t v_373 = seed.word(199); + row[layout.auxiliaries + 203] = v_373; + const uint64_t v_374 = seed.word(200); + row[layout.auxiliaries + 204] = v_374; + row[layout.selectors + 13] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 185] = (v_220 <= 1ULL ? inverse_114_13[v_220] : inverse(goldilocks_sub(v_220, 1ULL))); + const uint64_t v_377 = seed.word(181); + row[layout.auxiliaries + 186] = v_377; + const uint64_t v_378 = seed.word(182); + row[layout.auxiliaries + 187] = v_378; + row[layout.selectors + 14] = 1; + return 0; + } + } + } + } + } + } +} +template __global__ void kernel_multi_stark_114(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 544 : 1608; + const Seed_multi_stark_114 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_114(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_114(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_114<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_114<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_114(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 15 || width < auxiliaries || width - auxiliaries < 205) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 544 : encoding == 0 ? 1608 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_114); +} + +template struct Seed_multi_stark_172 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 360); + case 2: return load_u32(data + 364); + case 3: return load_u8(data + 448); + case 4: return load_u64(data + 8); + case 5: return load_u32(data + 368); + case 6: return load_u32(data + 372); + case 7: return load_u64(data + 16); + case 8: return load_u32(data + 376); + case 9: return load_u32(data + 380); + case 10: return load_u64(data + 24); + case 11: return load_u64(data + 32); + case 12: return load_u64(data + 40); + case 13: return load_u64(data + 48); + case 14: return load_u64(data + 56); + case 15: return load_u64(data + 64); + case 16: return load_u64(data + 72); + case 17: return load_u64(data + 80); + case 18: return load_u64(data + 88); + case 19: return load_u64(data + 96); + case 20: return load_u64(data + 104); + case 21: return load_u64(data + 112); + case 22: return load_u64(data + 120); + case 23: return load_u64(data + 128); + case 24: return load_u64(data + 136); + case 25: return load_u64(data + 144); + case 26: return load_u64(data + 152); + case 27: return load_u64(data + 160); + case 28: return load_u64(data + 168); + case 29: return load_u64(data + 176); + case 30: return load_u64(data + 184); + case 31: return load_u64(data + 192); + case 32: return load_u64(data + 200); + case 33: return load_u64(data + 208); + case 34: return load_u64(data + 216); + case 35: return load_u64(data + 224); + case 36: return load_u64(data + 232); + case 37: return load_u64(data + 240); + case 38: return load_u64(data + 248); + case 39: return load_u64(data + 256); + case 40: return load_u64(data + 264); + case 41: return load_u64(data + 272); + case 42: return load_u64(data + 280); + case 43: return load_u32(data + 384); + case 44: return load_u32(data + 388); + case 45: return load_u32(data + 392); + case 46: return load_u32(data + 396); + case 47: return load_u32(data + 400); + case 48: return load_u32(data + 404); + case 49: return load_u32(data + 408); + case 50: return load_u32(data + 412); + case 51: return load_u32(data + 416); + case 52: return load_u8(data + 449); + case 53: return load_u64(data + 288); + case 54: return load_u32(data + 420); + case 55: return load_u8(data + 450); + case 56: return load_u64(data + 296); + case 57: return load_u32(data + 424); + case 58: return load_u8(data + 451); + case 59: return load_u64(data + 304); + case 60: return load_u32(data + 428); + case 61: return load_u8(data + 452); + case 62: return load_u64(data + 312); + case 63: return load_u32(data + 432); + case 64: return load_u8(data + 453); + case 65: return load_u64(data + 320); + case 66: return load_u32(data + 436); + case 67: return load_u8(data + 454); + case 68: return load_u64(data + 328); + case 69: return load_u32(data + 440); + case 70: return load_u8(data + 455); + case 71: return load_u64(data + 336); + case 72: return load_u32(data + 444); + case 73: return load_u8(data + 456); + case 74: return load_u64(data + 344); + case 75: return load_u64(data + 352); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_172(Seed_multi_stark_172 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_37 = seed.word(6); + row[layout.auxiliaries + 4] = v_37; + const uint64_t v_39 = seed.word(7); + row[layout.auxiliaries + 5] = v_39; + const uint64_t v_40 = seed.word(8); + row[layout.auxiliaries + 6] = v_40; + const uint64_t v_41 = seed.word(9); + row[layout.auxiliaries + 7] = v_41; + const uint64_t v_42 = seed.word(10); + row[layout.auxiliaries + 8] = v_42; + const uint64_t v_43 = seed.word(11); + const uint64_t v_44 = seed.word(12); + const uint64_t v_45 = seed.word(13); + const uint64_t v_46 = seed.word(14); + const uint64_t v_47 = seed.word(15); + const uint64_t v_48 = seed.word(16); + const uint64_t v_49 = seed.word(17); + const uint64_t v_50 = seed.word(18); + const uint64_t v_51 = seed.word(19); + const uint64_t v_52 = seed.word(20); + const uint64_t v_53 = seed.word(21); + const uint64_t v_54 = seed.word(22); + const uint64_t v_55 = seed.word(23); + const uint64_t v_56 = seed.word(24); + const uint64_t v_57 = seed.word(25); + const uint64_t v_58 = seed.word(26); + const uint64_t v_59 = seed.word(27); + const uint64_t v_60 = seed.word(28); + const uint64_t v_61 = seed.word(29); + const uint64_t v_62 = seed.word(30); + const uint64_t v_63 = seed.word(31); + const uint64_t v_64 = seed.word(32); + const uint64_t v_65 = seed.word(33); + const uint64_t v_66 = seed.word(34); + const uint64_t v_67 = seed.word(35); + const uint64_t v_68 = seed.word(36); + const uint64_t v_69 = seed.word(37); + const uint64_t v_70 = seed.word(38); + const uint64_t v_71 = seed.word(39); + const uint64_t v_72 = seed.word(40); + const uint64_t v_73 = seed.word(41); + const uint64_t v_74 = seed.word(42); + row[layout.auxiliaries + 9] = v_43; + row[layout.auxiliaries + 10] = v_44; + row[layout.auxiliaries + 11] = v_45; + row[layout.auxiliaries + 12] = v_46; + row[layout.auxiliaries + 13] = v_47; + row[layout.auxiliaries + 14] = v_48; + row[layout.auxiliaries + 15] = v_49; + row[layout.auxiliaries + 16] = v_50; + row[layout.auxiliaries + 17] = v_51; + row[layout.auxiliaries + 18] = v_52; + row[layout.auxiliaries + 19] = v_53; + row[layout.auxiliaries + 20] = v_54; + row[layout.auxiliaries + 21] = v_55; + row[layout.auxiliaries + 22] = v_56; + row[layout.auxiliaries + 23] = v_57; + row[layout.auxiliaries + 24] = v_58; + row[layout.auxiliaries + 25] = v_59; + row[layout.auxiliaries + 26] = v_60; + row[layout.auxiliaries + 27] = v_61; + row[layout.auxiliaries + 28] = v_62; + row[layout.auxiliaries + 29] = v_63; + row[layout.auxiliaries + 30] = v_64; + row[layout.auxiliaries + 31] = v_65; + row[layout.auxiliaries + 32] = v_66; + row[layout.auxiliaries + 33] = v_67; + row[layout.auxiliaries + 34] = v_68; + row[layout.auxiliaries + 35] = v_69; + row[layout.auxiliaries + 36] = v_70; + row[layout.auxiliaries + 37] = v_71; + row[layout.auxiliaries + 38] = v_72; + row[layout.auxiliaries + 39] = v_73; + row[layout.auxiliaries + 40] = v_74; + const uint64_t v_75 = seed.word(43); + row[layout.auxiliaries + 41] = v_75; + const uint64_t v_76 = seed.word(44); + row[layout.auxiliaries + 42] = v_76; + const uint64_t v_77 = seed.word(45); + row[layout.auxiliaries + 43] = v_77; + const uint64_t v_78 = seed.word(46); + row[layout.auxiliaries + 44] = v_78; + const uint64_t v_79 = seed.word(47); + row[layout.auxiliaries + 45] = v_79; + const uint64_t v_80 = seed.word(48); + row[layout.auxiliaries + 46] = v_80; + const uint64_t v_81 = seed.word(49); + row[layout.auxiliaries + 47] = v_81; + const uint64_t v_82 = seed.word(50); + row[layout.auxiliaries + 48] = v_82; + const uint64_t v_83 = seed.word(51); + row[layout.auxiliaries + 49] = v_83; + const uint64_t v_84 = seed.word(52); + const uint64_t v_85 = seed.word(53); + const uint64_t v_86 = seed.word(54); + row[layout.auxiliaries + 50] = v_84; + row[layout.auxiliaries + 51] = v_85; + row[layout.auxiliaries + 52] = v_86; + switch (v_84) { + case 0ULL: { + const uint64_t v_87 = seed.word(55); + const uint64_t v_88 = seed.word(56); + const uint64_t v_89 = seed.word(57); + row[layout.auxiliaries + 53] = v_87; + row[layout.auxiliaries + 54] = v_88; + row[layout.auxiliaries + 55] = v_89; + switch (v_87) { + case 0ULL: { + const uint64_t v_90 = seed.word(58); + const uint64_t v_91 = seed.word(59); + const uint64_t v_92 = seed.word(60); + row[layout.auxiliaries + 56] = v_90; + row[layout.auxiliaries + 57] = v_91; + row[layout.auxiliaries + 58] = v_92; + switch (v_90) { + case 0ULL: { + const uint64_t v_93 = seed.word(61); + const uint64_t v_94 = seed.word(62); + const uint64_t v_95 = seed.word(63); + row[layout.auxiliaries + 59] = v_93; + row[layout.auxiliaries + 60] = v_94; + row[layout.auxiliaries + 61] = v_95; + switch (v_93) { + case 0ULL: { + const uint64_t v_96 = seed.word(64); + const uint64_t v_97 = seed.word(65); + const uint64_t v_98 = seed.word(66); + row[layout.auxiliaries + 62] = v_96; + row[layout.auxiliaries + 63] = v_97; + row[layout.auxiliaries + 64] = v_98; + switch (v_96) { + case 0ULL: { + const uint64_t v_99 = seed.word(67); + const uint64_t v_100 = seed.word(68); + const uint64_t v_101 = seed.word(69); + row[layout.auxiliaries + 65] = v_99; + row[layout.auxiliaries + 66] = v_100; + row[layout.auxiliaries + 67] = v_101; + switch (v_99) { + case 0ULL: { + const uint64_t v_102 = seed.word(70); + const uint64_t v_103 = seed.word(71); + const uint64_t v_104 = seed.word(72); + row[layout.auxiliaries + 68] = v_102; + row[layout.auxiliaries + 69] = v_103; + row[layout.auxiliaries + 70] = v_104; + switch (v_102) { + case 0ULL: { + const uint64_t v_105 = seed.word(73); + const uint64_t v_106 = seed.word(74); + const uint64_t v_107 = seed.word(75); + row[layout.auxiliaries + 71] = v_105; + row[layout.auxiliaries + 72] = v_106; + row[layout.auxiliaries + 73] = v_107; + switch (v_105) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + case 0ULL: { + const uint64_t v_108 = seed.word(6); + const uint64_t v_109 = seed.word(7); + const uint64_t v_110 = seed.word(8); + row[layout.auxiliaries + 4] = v_108; + row[layout.auxiliaries + 5] = v_109; + row[layout.auxiliaries + 6] = v_110; + switch (v_108) { + case 0ULL: { + const uint64_t v_111 = seed.word(9); + const uint64_t v_112 = seed.word(10); + const uint64_t v_113 = seed.word(11); + row[layout.auxiliaries + 7] = v_111; + row[layout.auxiliaries + 8] = v_112; + row[layout.auxiliaries + 9] = v_113; + switch (v_111) { + case 0ULL: { + const uint64_t v_114 = seed.word(12); + const uint64_t v_115 = seed.word(13); + const uint64_t v_116 = seed.word(14); + row[layout.auxiliaries + 10] = v_114; + row[layout.auxiliaries + 11] = v_115; + row[layout.auxiliaries + 12] = v_116; + switch (v_114) { + case 0ULL: { + const uint64_t v_117 = seed.word(15); + const uint64_t v_118 = seed.word(16); + const uint64_t v_119 = seed.word(17); + row[layout.auxiliaries + 13] = v_117; + row[layout.auxiliaries + 14] = v_118; + row[layout.auxiliaries + 15] = v_119; + switch (v_117) { + case 0ULL: { + const uint64_t v_120 = seed.word(18); + const uint64_t v_121 = seed.word(19); + const uint64_t v_122 = seed.word(20); + row[layout.auxiliaries + 16] = v_120; + row[layout.auxiliaries + 17] = v_121; + row[layout.auxiliaries + 18] = v_122; + switch (v_120) { + case 0ULL: { + const uint64_t v_123 = seed.word(21); + const uint64_t v_124 = seed.word(22); + const uint64_t v_125 = seed.word(23); + row[layout.auxiliaries + 19] = v_123; + row[layout.auxiliaries + 20] = v_124; + row[layout.auxiliaries + 21] = v_125; + switch (v_123) { + case 0ULL: { + const uint64_t v_126 = seed.word(24); + const uint64_t v_127 = seed.word(25); + const uint64_t v_128 = seed.word(26); + row[layout.auxiliaries + 22] = v_126; + row[layout.auxiliaries + 23] = v_127; + row[layout.auxiliaries + 24] = v_128; + switch (v_126) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_172(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 464 : 608; + const Seed_multi_stark_172 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_172(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_172(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_172<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_172<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_172(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 74) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 464 : encoding == 0 ? 608 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_172); +} + +template struct Seed_multi_stark_200 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 512); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u8(data + 604); + case 8: return load_u64(data + 48); + case 9: return load_u64(data + 56); + case 10: return load_u64(data + 64); + case 11: return load_u64(data + 72); + case 12: return load_u64(data + 80); + case 13: return load_u64(data + 88); + case 14: return load_u64(data + 96); + case 15: return load_u64(data + 104); + case 16: return load_u64(data + 112); + case 17: return load_u64(data + 120); + case 18: return load_u64(data + 128); + case 19: return load_u64(data + 136); + case 20: return load_u64(data + 144); + case 21: return load_u8(data + 605); + case 22: return load_u32(data + 516); + case 23: return load_u64(data + 152); + case 24: return load_u32(data + 520); + case 25: return load_u64(data + 160); + case 26: return load_u32(data + 524); + case 27: return load_u64(data + 168); + case 28: return load_u64(data + 176); + case 29: return load_u64(data + 184); + case 30: return load_u64(data + 192); + case 31: return load_u32(data + 528); + case 32: return load_u8(data + 606); + case 33: return load_u8(data + 607); + case 34: return load_u64(data + 200); + case 35: return load_u64(data + 208); + case 36: return load_u64(data + 216); + case 37: return load_u32(data + 532); + case 38: return load_u32(data + 536); + case 39: return load_u64(data + 224); + case 40: return load_u32(data + 540); + case 41: return load_u32(data + 544); + case 42: return load_u8(data + 608); + case 43: return load_u64(data + 232); + case 44: return load_u64(data + 240); + case 45: return load_u32(data + 548); + case 46: return load_u32(data + 552); + case 47: return load_u64(data + 248); + case 48: return load_u64(data + 256); + case 49: return load_u64(data + 264); + case 50: return load_u64(data + 272); + case 51: return load_u64(data + 280); + case 52: return load_u64(data + 288); + case 53: return load_u64(data + 296); + case 54: return load_u64(data + 304); + case 55: return load_u64(data + 312); + case 56: return load_u32(data + 556); + case 57: return load_u32(data + 560); + case 58: return load_u32(data + 564); + case 59: return load_u32(data + 568); + case 60: return load_u32(data + 572); + case 61: return load_u32(data + 576); + case 62: return load_u32(data + 580); + case 63: return load_u32(data + 584); + case 64: return load_u32(data + 588); + case 65: return load_u64(data + 320); + case 66: return load_u64(data + 328); + case 67: return load_u64(data + 336); + case 68: return load_u64(data + 344); + case 69: return load_u8(data + 609); + case 70: return load_u64(data + 352); + case 71: return load_u64(data + 360); + case 72: return load_u32(data + 592); + case 73: return load_u64(data + 368); + case 74: return load_u64(data + 376); + case 75: return load_u64(data + 384); + case 76: return load_u64(data + 392); + case 77: return load_u64(data + 400); + case 78: return load_u64(data + 408); + case 79: return load_u64(data + 416); + case 80: return load_u64(data + 424); + case 81: return load_u64(data + 432); + case 82: return load_u64(data + 440); + case 83: return load_u64(data + 448); + case 84: return load_u64(data + 456); + case 85: return load_u64(data + 464); + case 86: return load_u32(data + 596); + case 87: return load_u32(data + 600); + case 88: return load_u64(data + 472); + case 89: return load_u64(data + 480); + case 90: return load_u64(data + 488); + case 91: return load_u64(data + 496); + case 92: return load_u64(data + 504); + case 93: return load_u8(data + 610); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_200(Seed_multi_stark_200 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 1] = v_20; + row[layout.auxiliaries + 2] = v_21; + row[layout.auxiliaries + 3] = v_22; + row[layout.auxiliaries + 4] = v_23; + row[layout.auxiliaries + 5] = v_24; + row[layout.auxiliaries + 6] = v_25; + row[layout.auxiliaries + 7] = v_26; + row[layout.auxiliaries + 8] = v_27; + row[layout.auxiliaries + 9] = v_28; + row[layout.auxiliaries + 10] = v_29; + row[layout.auxiliaries + 11] = v_30; + switch (v_20) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + switch (v_21) { + default: { + const uint64_t v_32 = seed.word(32); + row[layout.auxiliaries + 12] = v_32; + const uint64_t v_33 = 32ULL; + if (v_32 > 255 || v_33 > 255) return 1; + const uint64_t v_34 = uint64_t(v_32 < v_33); + row[layout.auxiliaries + 13] = v_34; + const uint64_t v_36 = seed.word(33); + row[layout.auxiliaries + 14] = v_36; + const uint64_t v_37 = seed.word(34); + const uint64_t v_38 = seed.word(35); + row[layout.auxiliaries + 15] = v_37; + row[layout.auxiliaries + 16] = v_38; + const uint64_t v_39 = seed.word(36); + row[layout.auxiliaries + 17] = v_39; + const uint64_t v_41 = seed.word(37); + row[layout.auxiliaries + 18] = v_41; + const uint64_t v_42 = seed.word(38); + row[layout.auxiliaries + 19] = v_42; + const uint64_t v_43 = seed.word(39); + row[layout.auxiliaries + 20] = v_43; + const uint64_t v_44 = seed.word(40); + row[layout.auxiliaries + 21] = v_44; + const uint64_t v_45 = seed.word(41); + row[layout.auxiliaries + 22] = v_45; + const uint64_t v_46 = seed.word(42); + const uint64_t v_47 = seed.word(43); + row[layout.auxiliaries + 23] = v_46; + row[layout.auxiliaries + 24] = v_47; + uint64_t v_57; + uint64_t v_58; + switch (v_46) { + case 0ULL: { + const uint64_t v_49 = seed.word(44); + row[layout.auxiliaries + 25] = v_49; + row[layout.selectors + 1] = 1; + v_57 = v_49; + v_58 = v_49; + goto continuation_0; + } + case 1ULL: { + switch (v_6) { + case 0ULL: { + const uint64_t v_51 = seed.word(44); + row[layout.auxiliaries + 25] = v_51; + row[layout.selectors + 2] = 1; + v_57 = v_51; + v_58 = v_51; + goto continuation_0; + } + case 1ULL: { + const uint64_t v_52 = seed.word(44); + row[layout.auxiliaries + 25] = v_52; + const uint64_t v_54 = seed.word(45); + row[layout.auxiliaries + 26] = v_54; + const uint64_t v_56 = seed.word(46); + row[layout.auxiliaries + 27] = v_56; + row[layout.selectors + 3] = 1; + v_57 = v_54; + v_58 = v_56; + goto continuation_0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + continuation_0:; + row[layout.auxiliaries + 28] = v_57; + row[layout.auxiliaries + 29] = v_58; + const uint64_t v_59 = seed.word(47); + row[layout.auxiliaries + 30] = v_59; + const uint64_t v_60 = goldilocks_sub(v_59, v_27); + const uint64_t v_61 = uint64_t(v_60 == 0); + row[layout.auxiliaries + 31] = inverse(v_60); + row[layout.auxiliaries + 32] = v_61; + const uint64_t v_62 = 1ULL; + const uint64_t v_63 = seed.word(48); + row[layout.auxiliaries + 33] = v_63; + const uint64_t v_64 = goldilocks_sub(v_63, v_27); + const uint64_t v_65 = uint64_t(v_64 == 0); + row[layout.auxiliaries + 34] = inverse(v_64); + row[layout.auxiliaries + 35] = v_65; + const uint64_t v_66 = seed.word(49); + row[layout.auxiliaries + 36] = v_66; + const uint64_t v_67 = goldilocks_sub(v_66, v_29); + const uint64_t v_68 = uint64_t(v_67 == 0); + row[layout.auxiliaries + 37] = inverse(v_67); + row[layout.auxiliaries + 38] = v_68; + const uint64_t v_69 = seed.word(50); + row[layout.auxiliaries + 39] = v_69; + const uint64_t v_70 = goldilocks_sub(v_69, v_29); + const uint64_t v_71 = uint64_t(v_70 == 0); + row[layout.auxiliaries + 40] = inverse(v_70); + row[layout.auxiliaries + 41] = v_71; + const uint64_t v_72 = seed.word(51); + row[layout.auxiliaries + 42] = v_72; + const uint64_t v_73 = goldilocks_sub(v_72, v_28); + const uint64_t v_74 = uint64_t(v_73 == 0); + row[layout.auxiliaries + 43] = inverse(v_73); + row[layout.auxiliaries + 44] = v_74; + const uint64_t v_75 = seed.word(52); + row[layout.auxiliaries + 45] = v_75; + const uint64_t v_76 = goldilocks_sub(v_75, v_28); + const uint64_t v_77 = uint64_t(v_76 == 0); + row[layout.auxiliaries + 46] = inverse(v_76); + row[layout.auxiliaries + 47] = v_77; + const uint64_t v_78 = seed.word(53); + const uint64_t v_79 = seed.word(54); + row[layout.auxiliaries + 48] = v_78; + row[layout.auxiliaries + 49] = v_79; + const uint64_t v_80 = 0ULL; + const uint64_t v_81 = goldilocks_sub(v_78, v_62); + const uint64_t v_82 = goldilocks_sub(v_79, v_80); + const uint64_t v_83 = seed.word(55); + row[layout.auxiliaries + 50] = v_83; + const uint64_t v_84 = inverse(v_83); + row[layout.auxiliaries + 51] = v_84; + const uint64_t v_85 = goldilocks_mul(v_83, v_84); + row[layout.auxiliaries + 52] = v_85; + const uint64_t v_86 = goldilocks_sub(v_85, v_62); + const uint64_t v_87 = goldilocks_mul(v_83, v_86); + row[layout.auxiliaries + 53] = v_87; + const uint64_t v_88 = goldilocks_mul(v_84, v_86); + row[layout.auxiliaries + 54] = v_88; + const uint64_t v_89 = goldilocks_sub(v_18, v_62); + const uint64_t v_90 = goldilocks_sub(v_19, v_80); + const uint64_t v_91 = goldilocks_mul(v_89, v_89); + row[layout.auxiliaries + 55] = v_91; + const uint64_t v_92 = 7ULL; + const uint64_t v_93 = goldilocks_mul(v_90, v_90); + row[layout.auxiliaries + 56] = v_93; + const uint64_t v_94 = goldilocks_mul(v_92, v_93); + const uint64_t v_95 = goldilocks_sub(v_91, v_94); + const uint64_t v_96 = inverse(v_95); + row[layout.auxiliaries + 57] = v_96; + const uint64_t v_97 = goldilocks_mul(v_95, v_96); + row[layout.auxiliaries + 58] = v_97; + const uint64_t v_98 = goldilocks_sub(v_97, v_62); + const uint64_t v_99 = goldilocks_mul(v_95, v_98); + row[layout.auxiliaries + 59] = v_99; + const uint64_t v_100 = goldilocks_mul(v_96, v_98); + row[layout.auxiliaries + 60] = v_100; + const uint64_t v_101 = goldilocks_mul(v_89, v_96); + row[layout.auxiliaries + 61] = v_101; + const uint64_t v_102 = goldilocks_sub(v_80, v_90); + const uint64_t v_103 = goldilocks_mul(v_102, v_96); + row[layout.auxiliaries + 62] = v_103; + const uint64_t v_104 = goldilocks_mul(v_81, v_101); + row[layout.auxiliaries + 63] = v_104; + const uint64_t v_105 = goldilocks_mul(v_82, v_103); + row[layout.auxiliaries + 64] = v_105; + const uint64_t v_108 = goldilocks_mul(v_81, v_103); + row[layout.auxiliaries + 65] = v_108; + const uint64_t v_109 = goldilocks_mul(v_82, v_101); + row[layout.auxiliaries + 66] = v_109; + const uint64_t v_111 = goldilocks_sub(v_18, v_84); + const uint64_t v_112 = goldilocks_mul(v_111, v_111); + row[layout.auxiliaries + 67] = v_112; + const uint64_t v_113 = goldilocks_sub(v_112, v_94); + const uint64_t v_114 = inverse(v_113); + row[layout.auxiliaries + 68] = v_114; + const uint64_t v_115 = goldilocks_mul(v_113, v_114); + row[layout.auxiliaries + 69] = v_115; + const uint64_t v_116 = goldilocks_sub(v_115, v_62); + const uint64_t v_117 = goldilocks_mul(v_113, v_116); + row[layout.auxiliaries + 70] = v_117; + const uint64_t v_118 = goldilocks_mul(v_114, v_116); + row[layout.auxiliaries + 71] = v_118; + const uint64_t v_119 = goldilocks_mul(v_111, v_114); + row[layout.auxiliaries + 72] = v_119; + const uint64_t v_120 = goldilocks_mul(v_102, v_114); + row[layout.auxiliaries + 73] = v_120; + const uint64_t v_121 = goldilocks_mul(v_81, v_119); + row[layout.auxiliaries + 74] = v_121; + const uint64_t v_122 = goldilocks_mul(v_82, v_120); + row[layout.auxiliaries + 75] = v_122; + const uint64_t v_123 = goldilocks_mul(v_92, v_122); + const uint64_t v_124 = goldilocks_add(v_121, v_123); + const uint64_t v_125 = goldilocks_mul(v_81, v_120); + row[layout.auxiliaries + 76] = v_125; + const uint64_t v_126 = goldilocks_mul(v_82, v_119); + row[layout.auxiliaries + 77] = v_126; + const uint64_t v_127 = goldilocks_add(v_125, v_126); + const uint64_t v_128 = goldilocks_mul(v_81, v_81); + row[layout.auxiliaries + 78] = v_128; + const uint64_t v_129 = goldilocks_mul(v_82, v_82); + row[layout.auxiliaries + 79] = v_129; + const uint64_t v_130 = goldilocks_mul(v_92, v_129); + const uint64_t v_131 = goldilocks_sub(v_128, v_130); + const uint64_t v_132 = inverse(v_131); + row[layout.auxiliaries + 80] = v_132; + const uint64_t v_133 = goldilocks_mul(v_131, v_132); + row[layout.auxiliaries + 81] = v_133; + const uint64_t v_134 = goldilocks_sub(v_133, v_62); + const uint64_t v_135 = goldilocks_mul(v_131, v_134); + row[layout.auxiliaries + 82] = v_135; + const uint64_t v_136 = goldilocks_mul(v_132, v_134); + row[layout.auxiliaries + 83] = v_136; + const uint64_t v_137 = goldilocks_mul(v_81, v_132); + row[layout.auxiliaries + 84] = v_137; + const uint64_t v_138 = goldilocks_sub(v_80, v_82); + const uint64_t v_139 = goldilocks_mul(v_138, v_132); + row[layout.auxiliaries + 85] = v_139; + const uint64_t v_140 = seed.word(56); + row[layout.auxiliaries + 86] = v_140; + const uint64_t v_141 = seed.word(57); + row[layout.auxiliaries + 87] = v_141; + const uint64_t v_142 = seed.word(58); + row[layout.auxiliaries + 88] = v_142; + const uint64_t v_143 = seed.word(59); + row[layout.auxiliaries + 89] = v_143; + const uint64_t v_144 = seed.word(60); + row[layout.auxiliaries + 90] = v_144; + const uint64_t v_145 = seed.word(61); + row[layout.auxiliaries + 91] = v_145; + const uint64_t v_146 = seed.word(62); + row[layout.auxiliaries + 92] = v_146; + const uint64_t v_147 = seed.word(63); + row[layout.auxiliaries + 93] = v_147; + const uint64_t v_148 = seed.word(64); + row[layout.auxiliaries + 94] = v_148; + const uint64_t v_149 = seed.word(65); + row[layout.auxiliaries + 95] = v_149; + const uint64_t v_150 = seed.word(66); + row[layout.auxiliaries + 96] = v_150; + const uint64_t v_151 = goldilocks_mul(v_149, v_150); + row[layout.auxiliaries + 97] = v_151; + const uint64_t v_152 = inverse(v_151); + row[layout.auxiliaries + 98] = v_152; + const uint64_t v_153 = goldilocks_mul(v_151, v_152); + row[layout.auxiliaries + 99] = v_153; + const uint64_t v_154 = goldilocks_sub(v_153, v_62); + const uint64_t v_155 = goldilocks_mul(v_151, v_154); + row[layout.auxiliaries + 100] = v_155; + const uint64_t v_156 = goldilocks_mul(v_152, v_154); + row[layout.auxiliaries + 101] = v_156; + const uint64_t v_157 = seed.word(67); + const uint64_t v_158 = seed.word(68); + row[layout.auxiliaries + 102] = v_157; + row[layout.auxiliaries + 103] = v_158; + const uint64_t v_159 = goldilocks_sub(v_37, v_10); + const uint64_t v_160 = goldilocks_sub(v_80, v_80); + const uint64_t v_161 = goldilocks_mul(v_159, v_152); + row[layout.auxiliaries + 104] = v_161; + const uint64_t v_162 = goldilocks_mul(v_160, v_80); + const uint64_t v_163 = goldilocks_mul(v_92, v_162); + const uint64_t v_164 = goldilocks_add(v_161, v_163); + const uint64_t v_165 = goldilocks_mul(v_159, v_80); + const uint64_t v_166 = goldilocks_mul(v_160, v_152); + const uint64_t v_167 = goldilocks_add(v_165, v_166); + const uint64_t v_168 = goldilocks_mul(v_124, v_164); + row[layout.auxiliaries + 105] = v_168; + const uint64_t v_169 = goldilocks_mul(v_127, v_167); + row[layout.auxiliaries + 106] = v_169; + const uint64_t v_172 = goldilocks_mul(v_124, v_167); + row[layout.auxiliaries + 107] = v_172; + const uint64_t v_173 = goldilocks_mul(v_127, v_164); + row[layout.auxiliaries + 108] = v_173; + const uint64_t v_175 = goldilocks_sub(v_38, v_11); + const uint64_t v_176 = goldilocks_mul(v_175, v_152); + row[layout.auxiliaries + 109] = v_176; + const uint64_t v_177 = goldilocks_add(v_176, v_163); + const uint64_t v_178 = goldilocks_mul(v_175, v_80); + const uint64_t v_179 = goldilocks_add(v_178, v_166); + const uint64_t v_180 = goldilocks_mul(v_124, v_177); + row[layout.auxiliaries + 110] = v_180; + const uint64_t v_181 = goldilocks_mul(v_127, v_179); + row[layout.auxiliaries + 111] = v_181; + const uint64_t v_184 = goldilocks_mul(v_124, v_179); + row[layout.auxiliaries + 112] = v_184; + const uint64_t v_185 = goldilocks_mul(v_127, v_177); + row[layout.auxiliaries + 113] = v_185; + const uint64_t v_187 = seed.word(69); + const uint64_t v_188 = seed.word(70); + const uint64_t v_189 = seed.word(71); + const uint64_t v_190 = seed.word(72); + row[layout.auxiliaries + 114] = v_187; + row[layout.auxiliaries + 115] = v_188; + row[layout.auxiliaries + 116] = v_189; + row[layout.auxiliaries + 117] = v_190; + uint64_t v_218; + uint64_t v_219; + switch (v_187) { + case 1ULL: { + const uint64_t v_192 = seed.word(73); + const uint64_t v_193 = seed.word(74); + row[layout.auxiliaries + 118] = v_192; + row[layout.auxiliaries + 119] = v_193; + const uint64_t v_194 = seed.word(75); + const uint64_t v_195 = seed.word(76); + row[layout.auxiliaries + 120] = v_194; + row[layout.auxiliaries + 121] = v_195; + const uint64_t v_200 = seed.word(77); + const uint64_t v_201 = seed.word(78); + row[layout.auxiliaries + 122] = v_200; + row[layout.auxiliaries + 123] = v_201; + const uint64_t v_203 = seed.word(79); + const uint64_t v_204 = seed.word(80); + row[layout.auxiliaries + 124] = v_203; + row[layout.auxiliaries + 125] = v_204; + const uint64_t v_205 = seed.word(81); + const uint64_t v_206 = seed.word(82); + row[layout.auxiliaries + 126] = v_205; + row[layout.auxiliaries + 127] = v_206; + const uint64_t v_211 = seed.word(83); + const uint64_t v_212 = seed.word(84); + row[layout.auxiliaries + 128] = v_211; + row[layout.auxiliaries + 129] = v_212; + row[layout.selectors + 4] = 1; + v_218 = v_211; + v_219 = v_212; + goto continuation_1; + } + case 0ULL: { + const uint64_t v_214 = seed.word(73); + row[layout.auxiliaries + 118] = v_214; + const uint64_t v_216 = seed.word(74); + const uint64_t v_217 = seed.word(75); + row[layout.auxiliaries + 119] = v_216; + row[layout.auxiliaries + 120] = v_217; + row[layout.selectors + 5] = 1; + v_218 = v_216; + v_219 = v_217; + goto continuation_1; + } + default: { + return 2; + } + } + continuation_1:; + row[layout.auxiliaries + 130] = v_218; + row[layout.auxiliaries + 131] = v_219; + const uint64_t v_220 = seed.word(85); + row[layout.auxiliaries + 132] = v_220; + const uint64_t v_222 = seed.word(86); + row[layout.auxiliaries + 133] = v_222; + const uint64_t v_223 = seed.word(87); + row[layout.auxiliaries + 134] = v_223; + const uint64_t v_224 = seed.word(88); + row[layout.auxiliaries + 135] = v_224; + const uint64_t v_225 = goldilocks_sub(v_224, v_36); + const uint64_t v_226 = uint64_t(v_225 == 0); + row[layout.auxiliaries + 136] = inverse(v_225); + row[layout.auxiliaries + 137] = v_226; + const uint64_t v_228 = seed.word(89); + const uint64_t v_229 = seed.word(90); + row[layout.auxiliaries + 138] = v_228; + row[layout.auxiliaries + 139] = v_229; + const uint64_t v_230 = seed.word(91); + const uint64_t v_231 = seed.word(92); + row[layout.auxiliaries + 140] = v_230; + row[layout.auxiliaries + 141] = v_231; + const uint64_t v_232 = goldilocks_mul(v_218, v_137); + row[layout.auxiliaries + 142] = v_232; + const uint64_t v_233 = 7ULL; + const uint64_t v_234 = goldilocks_mul(v_219, v_139); + row[layout.auxiliaries + 143] = v_234; + const uint64_t v_235 = goldilocks_mul(v_233, v_234); + const uint64_t v_236 = goldilocks_add(v_232, v_235); + const uint64_t v_237 = goldilocks_mul(v_218, v_139); + row[layout.auxiliaries + 144] = v_237; + const uint64_t v_238 = goldilocks_mul(v_219, v_137); + row[layout.auxiliaries + 145] = v_238; + const uint64_t v_239 = goldilocks_add(v_237, v_238); + const uint64_t v_240 = goldilocks_sub(v_236, v_230); + const uint64_t v_241 = uint64_t(v_240 == 0); + row[layout.auxiliaries + 146] = inverse(v_240); + row[layout.auxiliaries + 147] = v_241; + const uint64_t v_242 = goldilocks_sub(v_239, v_231); + const uint64_t v_243 = uint64_t(v_242 == 0); + row[layout.auxiliaries + 148] = inverse(v_242); + row[layout.auxiliaries + 149] = v_243; + const uint64_t v_244 = goldilocks_mul(v_241, v_243); + row[layout.auxiliaries + 150] = v_244; + const uint64_t v_246 = seed.word(93); + row[layout.auxiliaries + 151] = v_246; + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_200(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 616 : 752; + const Seed_multi_stark_200 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_200(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_200(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_200<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_200<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_200(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 20 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 152) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 616 : encoding == 0 ? 752 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_200); +} + +template struct Seed_multi_stark_217 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 32); + case 4: return load_u32(data + 16); + case 5: return load_u32(data + 20); + case 6: return load_u8(data + 33); + case 7: return load_u32(data + 24); + case 8: return load_u32(data + 28); + case 9: return load_u8(data + 34); + case 10: return load_u8(data + 35); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_217(Seed_multi_stark_217 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_9 = seed.word(6); + const uint64_t v_10 = seed.word(7); + const uint64_t v_11 = seed.word(8); + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + switch (v_9) { + case 0ULL: { + const uint64_t v_12 = seed.word(9); + row[layout.auxiliaries + 7] = v_12; + const uint64_t v_14 = seed.word(10); + row[layout.auxiliaries + 8] = v_14; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_217(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 88; + const Seed_multi_stark_217 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_217(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_217(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_217<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_217<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_217(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_217); +} + +template struct Seed_multi_stark_227 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 72); + case 2: return load_u8(data + 73); + case 3: return load_u8(data + 74); + case 4: return load_u8(data + 75); + case 5: return load_u8(data + 76); + case 6: return load_u8(data + 77); + case 7: return load_u8(data + 78); + case 8: return load_u8(data + 79); + case 9: return load_u8(data + 80); + case 10: return load_u8(data + 81); + case 11: return load_u8(data + 82); + case 12: return load_u8(data + 83); + case 13: return load_u8(data + 84); + case 14: return load_u8(data + 85); + case 15: return load_u8(data + 86); + case 16: return load_u8(data + 87); + case 17: return load_u64(data + 8); + case 18: return load_u64(data + 16); + case 19: return load_u64(data + 24); + case 20: return load_u64(data + 32); + case 21: return load_u64(data + 40); + case 22: return load_u64(data + 48); + case 23: return load_u64(data + 56); + case 24: return load_u64(data + 64); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_227(Seed_multi_stark_227 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_17 = seed.word(17); + row[layout.auxiliaries + 1] = v_17; + const uint64_t v_18 = seed.word(18); + row[layout.auxiliaries + 2] = v_18; + const uint64_t v_19 = seed.word(19); + row[layout.auxiliaries + 3] = v_19; + const uint64_t v_20 = seed.word(20); + row[layout.auxiliaries + 4] = v_20; + const uint64_t v_21 = seed.word(21); + row[layout.auxiliaries + 5] = v_21; + const uint64_t v_22 = seed.word(22); + row[layout.auxiliaries + 6] = v_22; + const uint64_t v_23 = seed.word(23); + row[layout.auxiliaries + 7] = v_23; + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 8] = v_24; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_multi_stark_227(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 88 : 200; + const Seed_multi_stark_227 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_227(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_227(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_227<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_227<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_227(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 200 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_227); +} + +extern "C" const uint8_t* aiur_trace_multi_stark_contract() { + static const uint8_t hash[32] = {190, 78, 33, 75, 247, 82, 112, 163, 173, 204, 83, 141, 6, 196, 161, 203, 161, 99, 163, 87, 1, 40, 26, 136, 174, 21, 15, 159, 197, 168, 147, 208}; + return hash; +} +extern "C" const uint8_t* aiur_trace_multi_stark_schema() { + static const uint8_t hash[32] = {109, 2, 169, 223, 182, 235, 170, 183, 207, 233, 133, 131, 184, 190, 222, 84, 214, 112, 75, 166, 158, 14, 240, 158, 71, 104, 37, 253, 148, 167, 237, 188}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/trace-manifest.json b/crates/aiur/cuda/generated/production/trace-manifest.json new file mode 100644 index 000000000..3f715d057 --- /dev/null +++ b/crates/aiur/cuda/generated/production/trace-manifest.json @@ -0,0 +1,104 @@ +{"units": + [{"source": "cuda/generated/production/ixvm.cu", + "digest": + [170, + 176, + 122, + 30, + 75, + 1, + 58, + 190, + 202, + 122, + 7, + 159, + 66, + 153, + 249, + 209, + 124, + 221, + 69, + 71, + 203, + 117, + 99, + 72, + 14, + 87, + 134, + 135, + 60, + 251, + 199, + 44]}, + {"source": "cuda/generated/production/multi_stark.cu", + "digest": + [56, + 118, + 177, + 96, + 43, + 93, + 235, + 100, + 88, + 15, + 33, + 237, + 5, + 20, + 59, + 29, + 31, + 252, + 48, + 167, + 172, + 182, + 79, + 5, + 187, + 186, + 208, + 249, + 215, + 189, + 60, + 215]}, + {"source": "cuda/generated/production/ix_aggr.cu", + "digest": + [245, + 50, + 102, + 73, + 80, + 137, + 19, + 130, + 78, + 88, + 70, + 151, + 221, + 253, + 253, + 150, + 34, + 50, + 177, + 85, + 96, + 91, + 201, + 131, + 123, + 145, + 217, + 247, + 28, + 234, + 18, + 232]}], + "abi": 2} diff --git a/crates/aiur/cuda/trace-manifest.json b/crates/aiur/cuda/trace-manifest.json new file mode 100644 index 000000000..43e304a38 --- /dev/null +++ b/crates/aiur/cuda/trace-manifest.json @@ -0,0 +1,70 @@ +{"units": + [{"source": "cuda/generated/fixtures.cu", + "digest": + [80, + 2, + 183, + 205, + 35, + 134, + 155, + 0, + 164, + 41, + 110, + 82, + 189, + 178, + 247, + 63, + 143, + 56, + 104, + 96, + 140, + 96, + 50, + 82, + 82, + 77, + 45, + 67, + 5, + 131, + 215, + 169]}, + {"source": "cuda/generated/blake3.cu", + "digest": + [179, + 237, + 214, + 101, + 18, + 151, + 108, + 138, + 116, + 91, + 133, + 250, + 219, + 180, + 57, + 233, + 167, + 144, + 164, + 129, + 225, + 114, + 65, + 169, + 217, + 87, + 27, + 178, + 172, + 81, + 137, + 96]}], + "abi": 2} diff --git a/crates/aiur/src/trace_codegen.rs b/crates/aiur/src/trace_codegen.rs new file mode 100644 index 000000000..23cac4068 --- /dev/null +++ b/crates/aiur/src/trace_codegen.rs @@ -0,0 +1,818 @@ +//! Read-only seed preparation and canonical scalar rows for generated traces. +//! +//! Binding compares the complete bytecode library, including unconstrained +//! callees. Function numbers and widths alone do not identify a row writer. + +pub mod contract; +#[cfg(feature = "cuda-trace-codegen")] +pub mod cuda; +#[cfg(feature = "cuda-trace-codegen")] +pub(crate) mod programs; + +use std::fmt; + +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; + +use crate::{ + G, + bytecode::{Block, Ctrl, FunctionLayout, Toplevel}, + execute::{IOBuffer, QueryRecord, find_unconstrained_big_uint_div_mod}, +}; + +#[derive(Debug, PartialEq, Eq)] +pub struct TraceError { + pub function: usize, + pub query: Option, + pub operation: Option, + pub detail: String, +} + +impl fmt::Display for TraceError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "trace function {}", self.function)?; + if let Some(query) = self.query { + write!(f, " query {query}")?; + } + if let Some(operation) = self.operation { + write!(f, " operation {operation}")?; + } + write!(f, ": {}", self.detail) + } +} + +impl std::error::Error for TraceError {} + +pub type TraceResult = Result; + +pub fn error( + function: usize, + operation: Option, + detail: impl Into, +) -> TraceError { + TraceError { function, query: None, operation, detail: detail.into() } +} + +pub fn no_match(function: usize, value: G) -> TraceError { + error(function, None, format!("no match for {}", value.as_canonical_u64())) +} + +/// Borrows the finalized record and I/O for one row. No helper inserts a query +/// or changes its multiplicity. The owner must retain both across regeneration. +pub struct SeedContext<'a> { + pub inputs: &'a [G], + pub output: &'a [G], + pub multiplicity: G, + record: &'a QueryRecord, + io: &'a IOBuffer, + function: usize, +} + +impl SeedContext<'_> { + fn fail(&self, operation: usize, detail: impl Into) -> TraceError { + error(self.function, Some(operation), detail) + } + + pub fn call( + &self, + operation: usize, + callee: usize, + args: &[G], + ) -> TraceResult<[G; N]> { + let result = self + .record + .function_queries + .get(callee) + .and_then(|queries| queries.get(args)) + .ok_or_else(|| { + self.fail(operation, format!("missing call to function {callee}")) + })?; + result.output.try_into().map_err(|e| { + self.fail(operation, format!("call output arity is not {N}: {e}")) + }) + } + + pub fn returned( + &self, + operation: usize, + ) -> TraceResult<[G; N]> { + self.output.try_into().map_err(|e| { + self.fail(operation, format!("returned-call arity is not {N}: {e}")) + }) + } + + pub fn check_returned( + &self, + operation: usize, + callee: usize, + args: &[G], + ) -> TraceResult<[G; N]> { + let output = self.returned(operation)?; + if self.call::(operation, callee, args)? != output { + return Err(self.fail( + operation, + format!("returned-call alias disagrees with function {callee}"), + )); + } + Ok(output) + } + + pub fn store(&self, operation: usize, values: &[G]) -> TraceResult<[G; 1]> { + let index = self + .record + .memory_queries + .get(&values.len()) + .and_then(|table| table.get_index_of(values)) + .ok_or_else(|| self.fail(operation, "missing stored values"))?; + let pointer = self + .record + .pointer_base + .checked_add(index) + .ok_or_else(|| self.fail(operation, "memory pointer overflow"))?; + Ok([G::from_usize(pointer)]) + } + + pub fn load( + &self, + operation: usize, + pointer: G, + ) -> TraceResult<[G; N]> { + let index = usize::try_from(pointer.as_canonical_u64()) + .ok() + .and_then(|pointer| pointer.checked_sub(self.record.pointer_base)) + .ok_or_else(|| { + self.fail(operation, "pointer precedes this record's memory namespace") + })?; + let (values, _) = self + .record + .memory_queries + .get(&N) + .and_then(|table| table.get_index(index)) + .ok_or_else(|| self.fail(operation, "missing loaded values"))?; + values.try_into().map_err(|e| { + self.fail(operation, format!("memory width is not {N}: {e}")) + }) + } + + pub fn io_info( + &self, + operation: usize, + channel: G, + key: &[G], + ) -> TraceResult<[G; 2]> { + let info = self + .io + .get_info(channel, key) + .map_err(|e| self.fail(operation, e.to_string()))?; + Ok([G::from_usize(info.idx), G::from_usize(info.len)]) + } + + pub fn io_read( + &self, + operation: usize, + channel: G, + index: G, + ) -> TraceResult<[G; N]> { + let index = usize::try_from(index.as_canonical_u64()) + .map_err(|e| self.fail(operation, format!("I/O index overflow: {e}")))?; + self + .io + .read(channel, index, N) + .map_err(|e| self.fail(operation, e.to_string()))? + .try_into() + .map_err(|e| self.fail(operation, format!("I/O length is not {N}: {e}"))) + } + + pub fn big_uint(&self, operation: usize, a: G, b: G) -> TraceResult<[G; 2]> { + let (q, r) = find_unconstrained_big_uint_div_mod( + a, + b, + &self.record.memory_queries, + self.record.pointer_base, + ) + .map_err(|e| self.fail(operation, e))?; + Ok([q, r]) + } +} + +#[derive(Clone, Copy)] +pub struct RowOffsets { + pub selectors: usize, + pub auxiliaries: usize, +} + +/// Storage of one seed word in the typed encoding. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SeedWidth { + U8, + U16, + U32, + Full, +} + +impl SeedWidth { + pub const fn bytes(self) -> usize { + match self { + Self::U8 => 1, + Self::U16 => 2, + Self::U32 => 4, + Self::Full => 8, + } + } + + /// Whether a canonical value is representable at this width. + pub fn fits(self, value: u64) -> bool { + self == Self::Full || value >> (8 * self.bytes()) == 0 + } +} + +/// The compiler's per-word widths and byte offsets for one function's typed +/// seed. Word 0, the multiplicity, is full width at offset zero; wider words +/// precede narrower ones so every word is naturally aligned. +pub struct SeedSchema { + pub widths: &'static [SeedWidth], + pub offsets: &'static [usize], + pub bytes: usize, +} + +#[derive(Clone, Copy)] +struct InputRun { + first: usize, + len: usize, + width: SeedWidth, + offset: usize, +} + +impl SeedSchema { + /// Whether the offsets are the layout these widths dictate. + pub fn is_consistent(&self) -> bool { + if self.widths.len() != self.offsets.len() + || self.widths.first() != Some(&SeedWidth::Full) + { + return false; + } + let mut cursor = 0; + for width in + [SeedWidth::Full, SeedWidth::U32, SeedWidth::U16, SeedWidth::U8] + { + for (&candidate, &offset) in self.widths.iter().zip(self.offsets) { + if candidate == width { + if offset != cursor { + return false; + } + cursor += width.bytes(); + } + } + } + self.bytes == cursor.div_ceil(8) * 8 + } + + /// Whether the typed encoding is byte-for-byte the canonical one. + pub fn is_canonical(&self) -> bool { + self.widths.iter().all(|&width| width == SeedWidth::Full) + } + + /// Maximal runs of consecutive inputs sharing a width at contiguous + /// offsets. Each run packs as one loop, which vectorizes; per-word stores + /// with a width dispatch cost more than the record lookups they precede. + fn input_runs(&self, inputs: usize) -> Vec { + let mut runs: Vec = Vec::new(); + for input in 0..inputs { + let (width, offset) = (self.widths[1 + input], self.offsets[1 + input]); + if let Some(run) = runs.last_mut() + && run.width == width + && run.offset + run.len * width.bytes() == offset + { + run.len += 1; + continue; + } + runs.push(InputRun { first: input, len: 1, width, offset }); + } + runs + } + + fn store(bytes: &mut [u8], offset: usize, width: SeedWidth, value: u64) { + let le = value.to_le_bytes(); + bytes[offset..offset + width.bytes()].copy_from_slice(&le[..width.bytes()]); + } + + fn load(bytes: &[u8], offset: usize, width: SeedWidth) -> u64 { + let mut le = [0; 8]; + le[..width.bytes()].copy_from_slice(&bytes[offset..offset + width.bytes()]); + u64::from_le_bytes(le) + } + + /// Fails when a word exceeds its width; the caller then packs full width. + pub fn encode( + &self, + words: &[u64], + bytes: &mut [u8], + ) -> Result<(), &'static str> { + if words.len() != self.widths.len() || bytes.len() != self.bytes { + return Err("typed seed width mismatch"); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + bytes.fill(0); + for ((&word, &width), &offset) in + words.iter().zip(self.widths).zip(self.offsets) + { + if !width.fits(word) { + return Err("seed word exceeds its typed width"); + } + Self::store(bytes, offset, width, word); + } + Ok(()) + } + + pub fn decode( + &self, + bytes: &[u8], + words: &mut [u64], + ) -> Result<(), &'static str> { + if words.len() != self.widths.len() || bytes.len() != self.bytes { + return Err("typed seed width mismatch"); + } + let mut used = 0; + for ((word, &width), &offset) in + words.iter_mut().zip(self.widths).zip(self.offsets) + { + *word = Self::load(bytes, offset, width); + used = used.max(offset + width.bytes()); + } + if bytes[used..].iter().any(|&byte| byte != 0) { + return Err("nonzero seed padding"); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + Ok(()) + } +} + +/// A typed seed under construction. Narrow setters record any value that +/// exceeds its width; the caller must then discard the payload and pack the +/// row full width instead. The generated packer calls these with literal +/// offsets, so each is one store and one shift. +pub struct TypedSeed<'a> { + bytes: &'a mut [u8], + overflow: u64, +} + +#[allow(clippy::cast_possible_truncation)] +impl TypedSeed<'_> { + #[inline] + pub fn u8(&mut self, offset: usize, value: G) { + let value = value.as_canonical_u64(); + self.overflow |= value >> 8; + self.bytes[offset] = value as u8; + } + + #[inline] + pub fn u16(&mut self, offset: usize, value: G) { + let value = value.as_canonical_u64(); + self.overflow |= value >> 16; + self.bytes[offset..offset + 2] + .copy_from_slice(&(value as u16).to_le_bytes()); + } + + #[inline] + pub fn u32(&mut self, offset: usize, value: G) { + let value = value.as_canonical_u64(); + self.overflow |= value >> 32; + self.bytes[offset..offset + 4] + .copy_from_slice(&(value as u32).to_le_bytes()); + } + + #[inline] + pub fn full(&mut self, offset: usize, value: G) { + self.bytes[offset..offset + 8] + .copy_from_slice(&value.as_canonical_u64().to_le_bytes()); + } + + fn run(&mut self, run: InputRun, inputs: &[G]) { + let values = &inputs[run.first..run.first + run.len]; + let bytes = + &mut self.bytes[run.offset..run.offset + run.len * run.width.bytes()]; + let mut overflow = 0; + match run.width { + SeedWidth::U8 => { + for (dst, value) in bytes.iter_mut().zip(values) { + let value = value.as_canonical_u64(); + overflow |= value >> 8; + *dst = value as u8; + } + }, + SeedWidth::U16 => { + for (dst, value) in bytes.as_chunks_mut::<2>().0.iter_mut().zip(values) + { + let value = value.as_canonical_u64(); + overflow |= value >> 16; + dst.copy_from_slice(&(value as u16).to_le_bytes()); + } + }, + SeedWidth::U32 => { + for (dst, value) in bytes.as_chunks_mut::<4>().0.iter_mut().zip(values) + { + let value = value.as_canonical_u64(); + overflow |= value >> 32; + dst.copy_from_slice(&(value as u32).to_le_bytes()); + } + }, + SeedWidth::Full => { + for (dst, value) in bytes.as_chunks_mut::<8>().0.iter_mut().zip(values) + { + dst.copy_from_slice(&value.as_canonical_u64().to_le_bytes()); + } + }, + } + self.overflow |= overflow; + } +} + +#[derive(Clone, Copy)] +pub struct FunctionWriter { + pub layout: FunctionLayout, + pub output_size: usize, + pub seed_words: usize, + pub schema: &'static SeedSchema, + pub pack: fn(&SeedContext<'_>, &mut [u64]) -> TraceResult<()>, + pub pack_typed: fn(&SeedContext<'_>, &mut TypedSeed<'_>) -> TraceResult<()>, + pub pack_checked: fn(&SeedContext<'_>, &mut [u64]) -> TraceResult<()>, + pub write: fn(&[u64], RowOffsets, &mut [u64]) -> TraceResult<()>, +} + +pub struct GeneratedProgram { + pub fingerprint: [u8; 32], + pub complete: bool, + pub expected: fn() -> Toplevel, + pub functions: &'static [Option], +} + +pub struct BoundProgram<'a> { + generated: &'a GeneratedProgram, + bytecode: &'a Toplevel, +} + +pub struct BoundFunction<'a> { + index: usize, + writer: &'a FunctionWriter, + bytecode: &'a Toplevel, + input_runs: Vec, +} + +impl<'a> BoundFunction<'a> { + fn new( + index: usize, + writer: &'a FunctionWriter, + bytecode: &'a Toplevel, + ) -> Self { + let input_runs = writer.schema.input_runs(writer.layout.input_size); + Self { index, writer, bytecode, input_runs } + } +} + +fn same_block(a: &Block, b: &Block) -> bool { + let arms_equal = |a: &crate::FxIndexMap, + b: &crate::FxIndexMap| { + // Default-arm inverse columns follow case order; map equality ignores it. + a.len() == b.len() + && a.iter().zip(b).all(|((ka, a), (kb, b))| ka == kb && same_block(a, b)) + }; + let fallback_equal = + |a: &Option>, b: &Option>| match (a, b) { + (None, None) => true, + (Some(a), Some(b)) => same_block(a, b), + _ => false, + }; + a.ops == b.ops + && match (&a.ctrl, &b.ctrl) { + (Ctrl::Return(sa, va), Ctrl::Return(sb, vb)) + | (Ctrl::Yield(sa, va), Ctrl::Yield(sb, vb)) => sa == sb && va == vb, + (Ctrl::Match(da, aa, fa), Ctrl::Match(db, ab, fb)) => { + da == db && arms_equal(aa, ab) && fallback_equal(fa, fb) + }, + ( + Ctrl::MatchContinue(da, aa, fa, na, ca, la, ba), + Ctrl::MatchContinue(db, ab, fb, nb, cb, lb, bb), + ) => { + da == db + && na == nb + && ca == cb + && la == lb + && arms_equal(aa, ab) + && fallback_equal(fa, fb) + && same_block(ba, bb) + }, + _ => false, + } +} + +impl GeneratedProgram { + pub fn bind<'a>( + &'a self, + bytecode: &'a Toplevel, + ) -> Result, &'static str> { + let expected = (self.expected)(); + if self.fingerprint != contract::fingerprint(bytecode) + || !contract::validate_grouping(bytecode) + || expected.memory_sizes != bytecode.memory_sizes + || expected.functions.len() != bytecode.functions.len() + || self.functions.len() != bytecode.functions.len() + || expected.functions.iter().zip(&bytecode.functions).any(|(a, b)| { + !same_block(&a.body, &b.body) + || a.layout != b.layout + || a.entry != b.entry + || a.constrained != b.constrained + }) + { + return Err("generated trace library differs from the bytecode program"); + } + for (function, writer) in bytecode.functions.iter().zip(self.functions) { + if (self.complete && function.constrained && writer.is_none()) + || (!function.constrained && writer.is_some()) + || writer.as_ref().is_some_and(|writer| { + writer.layout != function.layout + || writer.schema.widths.len() != writer.seed_words + || !writer.schema.is_consistent() + }) + { + return Err( + "generated trace descriptors differ from the bytecode program", + ); + } + } + Ok(BoundProgram { generated: self, bytecode }) + } +} + +impl BoundProgram<'_> { + pub fn function(&self, index: usize) -> Option> { + Some(BoundFunction::new( + index, + self.generated.functions.get(index)?.as_ref()?, + self.bytecode, + )) + } +} + +impl BoundFunction<'_> { + pub fn seed_words(&self) -> usize { + self.writer.seed_words + } + + pub fn schema(&self) -> &'static SeedSchema { + self.writer.schema + } + + pub fn pack_row( + &self, + record: &QueryRecord, + io: &IOBuffer, + query: usize, + check_aliases: bool, + seed: &mut [u64], + ) -> TraceResult<()> { + if seed.len() != self.seed_words() { + return Err(error(self.index, None, "seed width mismatch")); + } + let (inputs, result) = record + .function_queries + .get(self.index) + .and_then(|queries| queries.get_index(query)) + .ok_or_else(|| error(self.index, None, "missing row query"))?; + if inputs.len() != self.writer.layout.input_size + || result.output.len() != self.writer.output_size + { + return Err(error(self.index, None, "row query arity mismatch")); + } + if result.multiplicity == G::ZERO { + return Err(error( + self.index, + None, + "zero-multiplicity function query has no trace row", + )); + } + seed.fill(0); + seed[0] = result.multiplicity.as_canonical_u64(); + for (dst, value) in seed[1..].iter_mut().zip(inputs) { + *dst = value.as_canonical_u64(); + } + let context = SeedContext { + inputs, + output: result.output, + multiplicity: result.multiplicity, + record, + io, + function: self.index, + }; + let pack = + if check_aliases { self.writer.pack_checked } else { self.writer.pack }; + pack(&context, seed).map_err(|mut error| { + error.query = Some(query); + error + }) + } + + /// Packs one row in the typed encoding and reports whether every narrowed + /// word fit. When one did not, the bytes are unusable and the row must be + /// packed full width. + pub fn pack_typed_row( + &self, + record: &QueryRecord, + io: &IOBuffer, + query: usize, + bytes: &mut [u8], + ) -> TraceResult { + let schema = self.writer.schema; + if bytes.len() != schema.bytes { + return Err(error(self.index, None, "typed seed width mismatch")); + } + let (inputs, result) = record + .function_queries + .get(self.index) + .and_then(|queries| queries.get_index(query)) + .ok_or_else(|| error(self.index, None, "missing row query"))?; + if inputs.len() != self.writer.layout.input_size + || result.output.len() != self.writer.output_size + || result.multiplicity == G::ZERO + { + return Err(error( + self.index, + None, + "row arity or multiplicity mismatch", + )); + } + bytes.fill(0); + bytes[..8] + .copy_from_slice(&result.multiplicity.as_canonical_u64().to_le_bytes()); + let mut seed = TypedSeed { bytes, overflow: 0 }; + for &run in &self.input_runs { + seed.run(run, inputs); + } + let context = SeedContext { + inputs, + output: result.output, + multiplicity: result.multiplicity, + record, + io, + function: self.index, + }; + (self.writer.pack_typed)(&context, &mut seed).map_err(|mut error| { + error.query = Some(query); + error + })?; + Ok(seed.overflow == 0) + } + + pub fn write_row( + &self, + seed: &[u64], + circuit: usize, + row: &mut [u64], + ) -> TraceResult<()> { + if seed.len() != self.seed_words() + || seed.first() == Some(&0) + || seed.iter().any(|&word| word >= G::ORDER_U64) + { + return Err(error( + self.index, + None, + "seed width, multiplicity, or canonical form mismatch", + )); + } + let circuit = self + .bytecode + .circuits + .get(circuit) + .ok_or_else(|| error(self.index, None, "missing circuit"))?; + let member = circuit + .members + .iter() + .position(|&member| member == self.index) + .ok_or_else(|| { + error(self.index, None, "function is not a member of this circuit") + })?; + if row.len() != circuit.layout.width() { + return Err(error(self.index, None, "row width mismatch")); + } + let selector_offset: usize = circuit.members[..member] + .iter() + .map(|&index| self.bytecode.functions[index].layout.selectors) + .sum(); + let offsets = RowOffsets { + selectors: circuit.layout.input_size + selector_offset, + auxiliaries: circuit.layout.input_size + circuit.layout.selectors, + }; + row.fill(0); + row[..self.writer.layout.input_size] + .copy_from_slice(&seed[1..1 + self.writer.layout.input_size]); + row[offsets.auxiliaries] = seed[0]; + (self.writer.write)(seed, offsets, row) + } +} + +/// Encoding is metadata for a homogeneous span, never inferred from byte +/// length. Multiplicities stay full width in both, including negative values. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SeedEncoding { + Canonical, + Typed, +} + +impl SeedEncoding { + pub fn stride(self, schema: &SeedSchema) -> usize { + match self { + Self::Canonical => 8 * schema.widths.len(), + Self::Typed => schema.bytes, + } + } + + pub fn encode( + self, + schema: &SeedSchema, + words: &[u64], + bytes: &mut [u8], + ) -> Result<(), &'static str> { + match self { + Self::Canonical => { + if words.len() != schema.widths.len() + || bytes.len() != self.stride(schema) + { + return Err("seed encoding width mismatch"); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + for (word, bytes) in words.iter().zip(bytes.as_chunks_mut::<8>().0) { + *bytes = word.to_le_bytes(); + } + Ok(()) + }, + Self::Typed => schema.encode(words, bytes), + } + } + + pub fn decode( + self, + schema: &SeedSchema, + bytes: &[u8], + words: &mut [u64], + ) -> Result<(), &'static str> { + match self { + Self::Canonical => { + if words.len() != schema.widths.len() + || bytes.len() != self.stride(schema) + { + return Err("seed encoding width mismatch"); + } + for (word, bytes) in words.iter_mut().zip(bytes.as_chunks::<8>().0) { + *word = u64::from_le_bytes(*bytes); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + Ok(()) + }, + Self::Typed => schema.decode(bytes, words), + } + } +} + +pub fn u32_word(bytes: [G; 4]) -> u64 { + bytes + .iter() + .enumerate() + .fold(0, |word, (i, byte)| word | (byte.as_canonical_u64() << (8 * i))) +} + +pub fn u32_add(words: &[u64]) -> [G; 5] { + let sum: u128 = words.iter().map(|&word| u128::from(word)).sum(); + let bytes = u32::try_from(sum & 0xffff_ffff) + .expect("32 bits") + .to_le_bytes() + .map(G::from_u8); + [ + bytes[0], + bytes[1], + bytes[2], + bytes[3], + G::from_u64(u64::try_from(sum >> 32).expect("carry fits")), + ] +} + +/// The comparison and its six u16 limbs ordered as `a`, `a - b`, `b`, low +/// limb first: the host witness's scalar range-check queries. +pub fn u32_less_than(a: G, b: G) -> (G, [G; 6]) { + let a = u32::try_from(a.as_canonical_u64()).expect("u32 operand"); + let b = u32::try_from(b.as_canonical_u64()).expect("u32 operand"); + let c = a.wrapping_sub(b); + let mut limbs = [G::ZERO; 6]; + for (dst, word) in limbs.as_chunks_mut::<2>().0.iter_mut().zip([a, c, b]) { + *dst = [G::from_u32(word & 0xffff), G::from_u32(word >> 16)]; + } + (G::from_bool(a < b), limbs) +} + +#[cfg(test)] +pub(crate) mod tests; diff --git a/crates/aiur/src/trace_codegen/contract.rs b/crates/aiur/src/trace_codegen/contract.rs new file mode 100644 index 000000000..ff0fd1181 --- /dev/null +++ b/crates/aiur/src/trace_codegen/contract.rs @@ -0,0 +1,225 @@ +//! Versioned bytecode identity shared with `Aiur.TraceContract`. + +use super::*; +use crate::bytecode::{Ctrl, Op}; + +struct Encoder(blake3::Hasher); +impl Encoder { + fn byte(&mut self, value: u8) { + self.0.update(&[value]); + } + fn word(&mut self, value: u64) { + self.0.update(&value.to_le_bytes()); + } + fn index(&mut self, value: usize) { + self.word(value.try_into().expect("64-bit index")); + } + fn indices(&mut self, values: &[usize]) { + self.index(values.len()); + for &value in values { + self.index(value); + } + } + fn string(&mut self, value: &str) { + self.index(value.len()); + self.0.update(value.as_bytes()); + } + fn unary(&mut self, tag: u8, a: usize) { + self.byte(tag); + self.index(a); + } + fn binary(&mut self, tag: u8, a: usize, b: usize) { + self.unary(tag, a); + self.index(b); + } + fn operation(&mut self, op: &Op) { + match op { + Op::Const(g) => { + self.byte(0); + self.word(g.as_canonical_u64()); + }, + Op::Add(a, b) => self.binary(1, *a, *b), + Op::Sub(a, b) => self.binary(2, *a, *b), + Op::Mul(a, b) => self.binary(3, *a, *b), + Op::EqZero(a) => self.unary(4, *a), + Op::Call(f, args, n, u) => { + self.unary(5, *f); + self.indices(args); + self.index(*n); + self.byte(u8::from(*u)); + }, + Op::Store(xs) => { + self.byte(6); + self.indices(xs); + }, + Op::Load(n, p) => self.binary(7, *n, *p), + Op::AssertEq(a, b, msg) => { + self.byte(8); + self.indices(a); + self.indices(b); + self.byte(u8::from(msg.is_some())); + if let Some(msg) = msg { + self.string(msg); + } + }, + Op::IOGetInfo(c, key) => { + self.unary(9, *c); + self.indices(key); + }, + Op::IOSetInfo(c, key, i, n) => { + self.unary(10, *c); + self.indices(key); + self.index(*i); + self.index(*n); + }, + Op::IORead(c, i, n) => { + self.binary(11, *c, *i); + self.index(*n); + }, + Op::IOWrite(c, xs) => { + self.unary(12, *c); + self.indices(xs); + }, + Op::U8BitDecomposition(a) => self.unary(13, *a), + Op::U8ShiftLeft(a) => self.unary(14, *a), + Op::U8ShiftRight(a) => self.unary(15, *a), + Op::U8Xor(a, b) => self.binary(16, *a, *b), + Op::U8Add(a, b) => self.binary(17, *a, *b), + Op::U8Mul(a, b) => self.binary(18, *a, *b), + Op::U8Sub(a, b) => self.binary(19, *a, *b), + Op::U8And(a, b) => self.binary(20, *a, *b), + Op::U8Or(a, b) => self.binary(21, *a, *b), + Op::U8LessThan(a, b) => self.binary(22, *a, *b), + Op::U32LessThan(a, b) => self.binary(23, *a, *b), + Op::U8XorSplit7(a, b) => self.binary(24, *a, *b), + Op::U8XorSplit4(a, b) => self.binary(25, *a, *b), + Op::Debug(msg, args) => { + self.byte(26); + self.string(msg); + self.byte(u8::from(args.is_some())); + if let Some(args) = args { + self.indices(args); + } + }, + Op::U8RangeCheck(a, b) => self.binary(27, *a, *b), + Op::UnconstrainedBigUintDivMod(a, b) => self.binary(28, *a, *b), + Op::UnconstrainedGToBytes(a) => self.unary(29, *a), + Op::UnconstrainedGInverse(a) => self.unary(30, *a), + Op::UnconstrainedU32Add(a, b) => { + self.byte(31); + self.indices(a); + self.indices(b); + }, + Op::UnconstrainedU32Add3(a, b, c) => { + self.byte(32); + self.indices(a); + self.indices(b); + self.indices(c); + }, + Op::U32ToField(a) => { + self.byte(33); + self.indices(a); + }, + } + } + fn arms( + &mut self, + arms: &crate::FxIndexMap, + fallback: &Option>, + ) { + self.index(arms.len()); + for (value, block) in arms { + self.word(value.as_canonical_u64()); + self.block(block); + } + self.byte(u8::from(fallback.is_some())); + if let Some(block) = fallback { + self.block(block); + } + } + fn block(&mut self, block: &Block) { + self.index(block.ops.len()); + for op in &block.ops { + self.operation(op); + } + match &block.ctrl { + Ctrl::Match(d, arms, fallback) => { + self.unary(0, *d); + self.arms(arms, fallback); + }, + Ctrl::Return(s, xs) => { + self.unary(1, *s); + self.indices(xs); + }, + Ctrl::Yield(s, xs) => { + self.unary(2, *s); + self.indices(xs); + }, + Ctrl::MatchContinue(d, arms, fallback, n, aux, lookup, continuation) => { + self.unary(3, *d); + self.arms(arms, fallback); + self.index(*n); + self.index(*aux); + self.index(*lookup); + self.block(continuation); + }, + } + } + fn layout(&mut self, l: &FunctionLayout) { + self.index(l.input_size); + self.index(l.selectors); + self.index(l.auxiliaries); + self.index(l.lookups); + } +} + +/// Grouping is validated separately so one writer can populate singleton or +/// merged circuits without changing its function-library identity. +pub fn fingerprint(top: &Toplevel) -> [u8; 32] { + let mut e = Encoder(blake3::Hasher::new()); + e.0.update(b"aiur-trace-library-v1/seed-v2/writer-v2\0"); + e.index(top.functions.len()); + for function in &top.functions { + e.layout(&function.layout); + e.byte(u8::from(function.entry)); + e.byte(u8::from(function.constrained)); + e.block(&function.body); + } + e.indices(&top.memory_sizes); + *e.0.finalize().as_bytes() +} + +pub(super) fn validate_grouping(top: &Toplevel) -> bool { + let mut seen = vec![false; top.functions.len()]; + for circuit in &top.circuits { + let mut layout = FunctionLayout { + input_size: 0, + selectors: 0, + auxiliaries: 0, + lookups: 0, + }; + if circuit.members.is_empty() { + return false; + } + for &member in &circuit.members { + let Some(function) = top.functions.get(member) else { + return false; + }; + if !function.constrained || std::mem::replace(&mut seen[member], true) { + return false; + } + let l = function.layout; + layout.input_size = layout.input_size.max(l.input_size); + let Some(selectors) = layout.selectors.checked_add(l.selectors) else { + return false; + }; + layout.selectors = selectors; + layout.auxiliaries = layout.auxiliaries.max(l.auxiliaries); + layout.lookups = layout.lookups.max(l.lookups); + } + if layout != circuit.layout { + return false; + } + } + seen.iter().zip(&top.functions).all(|(&seen, f)| seen == f.constrained) +} diff --git a/crates/aiur/src/trace_codegen/cuda.rs b/crates/aiur/src/trace_codegen/cuda.rs new file mode 100644 index 000000000..0b6feeeec --- /dev/null +++ b/crates/aiur/src/trace_codegen/cuda.rs @@ -0,0 +1,946 @@ +//! CUDA rows from owned, immutable, encoded seeds. + +use std::sync::{ + Arc, Mutex, OnceLock, + atomic::{AtomicUsize, Ordering}, +}; + +use rayon::prelude::*; + +use multi_stark::{ + cuda::DeviceTraceView, + lookup::LookupValues, + witness::{TraceGenerator, TraceSource}, +}; + +use super::*; +use crate::trace::QueryPosition; + +const MAX_ROWS: usize = 65537; +const MAX_SEED_BYTES: usize = 16 * 1024 * 1024 - 8; + +type Kernel = unsafe extern "C" fn( + i32, + *const u8, + u32, + usize, + usize, + usize, + usize, + usize, + *mut u64, +) -> i32; + +pub struct CudaLibrary { + fingerprint: [u8; 32], + contract: unsafe extern "C" fn() -> *const u8, + schema: unsafe extern "C" fn() -> *const u8, + functions: &'static [Option], + seed_words: &'static [usize], + typed_bytes: &'static [usize], +} + +/// The seed layouts the compiled unit was generated with, as the unit hashes +/// them: the same encoding `Aiur.TraceCuda` emits into `aiur_trace_*_schema`, +/// recomputed here from the Rust writers so the kernels' typed loads and the +/// packers' typed stores are proven to agree at bind, not assumed from a +/// shared generation run. +pub fn schema_contract(functions: &[Option]) -> [u8; 32] { + let mut hasher = blake3::Hasher::new(); + hasher.update(b"aiur-trace-schema-v1\0"); + for (index, writer) in functions.iter().enumerate() { + let Some(writer) = writer else { continue }; + for word in [index, writer.seed_words, writer.schema.bytes] { + hasher.update(&(word as u64).to_le_bytes()); + } + for &width in writer.schema.widths { + hasher.update(&[width.bytes() as u8]); + } + for &offset in writer.schema.offsets { + hasher.update(&(offset as u64).to_le_bytes()); + } + } + *hasher.finalize().as_bytes() +} + +impl CudaLibrary { + /// # Safety + /// The contract and schema functions must return 32 readable immutable + /// bytes. Every kernel must implement the generated seed/writer ABI for its + /// function index, validate output dimensions, and finish all accesses + /// before returning. + pub const unsafe fn new( + fingerprint: [u8; 32], + contract: unsafe extern "C" fn() -> *const u8, + schema: unsafe extern "C" fn() -> *const u8, + functions: &'static [Option], + seed_words: &'static [usize], + typed_bytes: &'static [usize], + ) -> Self { + Self { fingerprint, contract, schema, functions, seed_words, typed_bytes } + } + + pub fn bind<'a>( + &'static self, + generated: &'static GeneratedProgram, + bytecode: &'a Toplevel, + ) -> Result, &'static str> { + generated.bind(bytecode)?; + let compiled = unsafe { std::slice::from_raw_parts((self.contract)(), 32) }; + if generated.fingerprint != self.fingerprint + || compiled != self.fingerprint + || self.functions.len() != generated.functions.len() + || self.seed_words.len() != self.functions.len() + || self.typed_bytes.len() != self.functions.len() + { + return Err("CUDA unit differs from the generated seed/writer contract"); + } + let schemas = unsafe { std::slice::from_raw_parts((self.schema)(), 32) }; + if schemas != schema_contract(generated.functions) { + return Err("CUDA unit was compiled for different seed layouts"); + } + for (((kernel, writer), &words), &typed) in self + .functions + .iter() + .zip(generated.functions) + .zip(self.seed_words) + .zip(self.typed_bytes) + { + if kernel.is_some() + && writer.as_ref().is_none_or(|writer| { + writer.seed_words != words || writer.schema.bytes != typed + }) + { + return Err("CUDA kernel has no matching seed writer"); + } + } + Ok(BoundCudaProgram { library: self, generated, bytecode }) + } + + pub(crate) fn register( + &'static self, + generated: &'static GeneratedProgram, + bytecode: Arc, + ) -> Result { + self.bind(generated, &bytecode)?; + Ok(RegisteredCudaProgram { library: self, generated, bytecode }) + } +} + +/// A validated library and its immutable bytecode travel together across GPUs. +pub(crate) struct RegisteredCudaProgram { + library: &'static CudaLibrary, + generated: &'static GeneratedProgram, + bytecode: Arc, +} + +impl RegisteredCudaProgram { + pub(crate) fn bound(&self) -> BoundCudaProgram<'_> { + BoundCudaProgram { + library: self.library, + generated: self.generated, + bytecode: &self.bytecode, + } + } +} + +pub struct BoundCudaProgram<'a> { + library: &'static CudaLibrary, + generated: &'static GeneratedProgram, + bytecode: &'a Toplevel, +} + +impl BoundCudaProgram<'_> { + pub fn supports(&self, circuit: usize) -> bool { + self.bytecode.circuits.get(circuit).is_some_and(|c| { + c.members.iter().all(|&f| self.library.functions[f].is_some()) + }) + } + + /// The finalized record and I/O stay borrowed until packing finishes. The + /// returned source owns its seeds; dropping or regenerating another batch + /// cannot change these rows. + /// + /// With `retain_device_seeds`, the first device tile the source serves + /// uploads every seed span once and later tiles, such as the lookup pass's + /// regeneration of a committed trace, run from that copy; the backend + /// frees it after the lookup or under memory pressure. + pub fn prepare( + &self, + circuit: usize, + record: &QueryRecord, + io: &IOBuffer, + slots: &[usize], + start: QueryPosition, + end: QueryPosition, + row_count: usize, + check_aliases: bool, + retain_device_seeds: bool, + ) -> TraceResult<(TraceSource, LookupValues)> { + let _span = + tracing::info_span!("aiur/codegen_seeds", circuit, rows = row_count) + .entered(); + if !self.supports(circuit) || row_count == 0 { + return Err(error( + 0, + None, + "missing CUDA circuit coverage or empty span", + )); + } + let c = &self.bytecode.circuits[circuit]; + let mut spans: Vec = Vec::new(); + let mut count = 0usize; + let mut selectors = c.layout.input_size; + for (member, &function) in c.members.iter().enumerate() { + let writer = self.generated.functions[function].as_ref().unwrap(); + let offsets = RowOffsets { + selectors, + auxiliaries: c.layout.input_size + c.layout.selectors, + }; + selectors += writer.layout.selectors; + if member < start.0 || member > end.0 { + continue; + } + let bound = BoundFunction::new(function, writer, self.bytecode); + let queries = record + .function_queries + .get(function) + .ok_or_else(|| error(function, None, "record has no function table"))?; + let lo = if member == start.0 { start.1 } else { 0 }; + let hi = if member == end.0 { end.1 } else { queries.len() }; + if lo > hi || hi > queries.len() { + return Err(error(function, None, "invalid query span")); + } + let schema = writer.schema; + if SeedEncoding::Canonical.stride(schema) > MAX_SEED_BYTES { + return Err(error(function, None, "seed exceeds the upload limit")); + } + let live: Vec = { + let _filter = + tracing::info_span!("aiur/codegen_filter", function).entered(); + (lo..hi) + .filter(|&query| { + queries.get_index(query).unwrap().1.multiplicity != G::ZERO + }) + .collect() + }; + if live.is_empty() { + continue; + } + // Chunks pack in parallel. A chunk is typed while every narrowed word + // fits and turns full width at its first wide row, re-encoding its + // earlier rows from their typed bytes. A member run then takes one + // codec: if any chunk turned, the others are widened the same way, so + // no row is ever packed twice and no span mixes encodings. + let typed_first = !check_aliases && !schema.is_canonical(); + let mut chunks = { + let _pack = + tracing::info_span!("aiur/codegen_pack", function, rows = live.len()) + .entered(); + live + .par_chunks(CHUNK_ROWS) + .map(|rows| { + pack_chunk(&bound, record, io, rows, typed_first, check_aliases) + }) + .collect::>>()? + }; + if typed_first + && chunks.iter().any(|chunk| chunk.encoding == SeedEncoding::Canonical) + { + let _widen = + tracing::info_span!("aiur/codegen_widen", function).entered(); + chunks.par_iter_mut().for_each(|chunk| chunk.widen(schema)); + } + if tracing::enabled!(target: "prover_metrics", tracing::Level::INFO) { + let canonical = + chunks.first().is_some_and(|c| c.encoding == SeedEncoding::Canonical); + tracing::info!(target: "prover_metrics", metric = "seed_pack", + circuit, function, rows = live.len(), scanned_rows = hi - lo, + seed_bytes = chunks.iter().map(|c| c.bytes.len()).sum::(), + canonical_seed_bytes = live.len().saturating_mul(SeedEncoding::Canonical.stride(schema)), + encoding = if canonical { "canonical" } else { "typed" }, + widened_runs = usize::from(typed_first && canonical), chunks = chunks.len()); + } + let _concat = + tracing::info_span!("aiur/codegen_concat", function).entered(); + // Every chunk of the run now shares one encoding, so a span's final + // size is known when it opens: the rest of the run, within the tile and + // staging limits. + let mut run_remaining: usize = + chunks.iter().map(|chunk| chunk.rows).sum(); + for chunk in chunks { + let stride = chunk.encoding.stride(schema); + let mut offset = 0; + let mut remaining = chunk.rows; + while remaining > 0 { + let open = spans.last().is_some_and(|s| { + s.function == function + && s.encoding == chunk.encoding + && s.rows < MAX_ROWS + && s.bytes.len() + stride <= MAX_SEED_BYTES + }); + if !open { + spans.push(SeedSpan { + first: count, + rows: 0, + function, + writer, + kernel: self.library.functions[function].unwrap(), + offsets, + encoding: chunk.encoding, + stride, + bytes: Vec::with_capacity( + run_remaining.min(MAX_ROWS).min(MAX_SEED_BYTES / stride) + * stride, + ), + }); + } + let span = spans.last_mut().unwrap(); + let take = remaining + .min(MAX_ROWS - span.rows) + .min((MAX_SEED_BYTES - span.bytes.len()) / stride); + span + .bytes + .extend_from_slice(&chunk.bytes[offset..offset + take * stride]); + span.rows += take; + count += take; + offset += take * stride; + remaining -= take; + run_remaining -= take; + } + } + } + if count != row_count { + return Err(error(0, None, "packed row count differs from query span")); + } + let height = count + .checked_next_power_of_two() + .ok_or_else(|| error(0, None, "trace height overflow"))?; + let source = CudaTrace::new( + spans, + height, + count, + c.layout.width(), + retain_device_seeds, + ); + tracing::debug!( + circuit, + rows = count, + width = source.width, + seed_bytes = + source.spans.iter().map(|span| span.bytes.len()).sum::(), + seed_spans = source.spans.len(), + "prepared generated CUDA trace" + ); + Ok(( + TraceSource::Generated(Arc::new(source)), + LookupValues::shape_only(height, slots), + )) + } +} + +struct SeedSpan { + first: usize, + rows: usize, + function: usize, + writer: &'static FunctionWriter, + kernel: Kernel, + offsets: RowOffsets, + encoding: SeedEncoding, + stride: usize, + bytes: Vec, +} + +/// Rows packed together by one worker; see `prepare`. +const CHUNK_ROWS: usize = 4096; + +struct PackedChunk { + rows: usize, + encoding: SeedEncoding, + bytes: Vec, +} + +impl PackedChunk { + /// Typed bytes decode exactly, so widening never packs a row again. + fn widen(&mut self, schema: &SeedSchema) { + if self.encoding == SeedEncoding::Typed { + self.bytes = widen_bytes(&self.bytes, schema); + self.encoding = SeedEncoding::Canonical; + } + } +} + +fn widen_bytes(typed: &[u8], schema: &SeedSchema) -> Vec { + let typed_stride = schema.bytes; + let canonical_stride = SeedEncoding::Canonical.stride(schema); + let rows = typed.len() / typed_stride; + let mut words = vec![0; schema.widths.len()]; + let mut canonical = vec![0; rows * canonical_stride]; + for row in 0..rows { + schema + .decode(&typed[row * typed_stride..(row + 1) * typed_stride], &mut words) + .expect("typed rows were validated"); + SeedEncoding::Canonical + .encode( + schema, + &words, + &mut canonical[row * canonical_stride..(row + 1) * canonical_stride], + ) + .expect("decoded words are canonical"); + } + canonical +} + +fn pack_chunk( + bound: &BoundFunction<'_>, + record: &QueryRecord, + io: &IOBuffer, + rows: &[usize], + typed_first: bool, + check_aliases: bool, +) -> TraceResult { + let schema = bound.schema(); + let typed_stride = schema.bytes; + let canonical_stride = SeedEncoding::Canonical.stride(schema); + let mut encoding = + if typed_first { SeedEncoding::Typed } else { SeedEncoding::Canonical }; + let mut bytes = Vec::with_capacity(rows.len() * encoding.stride(schema)); + let mut seed = vec![0; bound.seed_words()]; + for &query in rows { + if encoding == SeedEncoding::Typed { + let offset = bytes.len(); + bytes.resize(offset + typed_stride, 0); + if bound.pack_typed_row(record, io, query, &mut bytes[offset..])? { + continue; + } + bytes.truncate(offset); + bytes = widen_bytes(&bytes, schema); + encoding = SeedEncoding::Canonical; + } + bound.pack_row(record, io, query, check_aliases, &mut seed)?; + let offset = bytes.len(); + bytes.resize(offset + canonical_stride, 0); + SeedEncoding::Canonical + .encode(schema, &seed, &mut bytes[offset..]) + .map_err(|e| error(bound.index, None, e))?; + } + Ok(PackedChunk { rows: rows.len(), encoding, bytes }) +} + +pub struct CudaTrace { + spans: Vec, + height: usize, + real: usize, + width: usize, + /// Byte offset of each span in the device copy of all seeds, then the + /// total, so a span's device seeds are `base + offsets[span]`. + offsets: Vec, + retain_device_seeds: bool, + device_seeds: Mutex>, +} + +/// One device's copy of every seed span of a source. +struct DeviceSeeds { + device: i32, + base: *mut u8, + hits: usize, +} + +// SAFETY: the pointer is a device allocation the CUDA runtime hands out +// and frees; no host thread dereferences it. +unsafe impl Send for DeviceSeeds {} + +/// Device seed bytes held per device across the process, against +/// [`seed_cache_limit`]. +static SEED_CACHE_BYTES: [AtomicUsize; 64] = + [const { AtomicUsize::new(0) }; 64]; +static SEED_CACHE_REFUSALS: [AtomicUsize; 64] = + [const { AtomicUsize::new(0) }; 64]; + +/// Current retained bytes and cumulative refused cache requests per device. +/// Snapshots can overlap work from concurrent proofs on the same device. +pub fn seed_cache_snapshot() -> Vec<(usize, usize, usize)> { + (0..64) + .filter_map(|device| { + let bytes = SEED_CACHE_BYTES[device].load(Ordering::Relaxed); + let refused = SEED_CACHE_REFUSALS[device].load(Ordering::Relaxed); + (bytes != 0 || refused != 0).then_some((device, bytes, refused)) + }) + .collect() +} + +/// The most seed bytes kept resident per device, `AIUR_GPU_SEED_CACHE_BYTES` +/// or 16 GiB. The backend releases caches before it spills any LDE, so the +/// limit bounds the footprint rather than protecting admission. +fn seed_cache_limit() -> usize { + static LIMIT: OnceLock = OnceLock::new(); + *LIMIT.get_or_init(|| { + std::env::var("AIUR_GPU_SEED_CACHE_BYTES") + .ok() + .and_then(|value| value.parse().ok()) + .unwrap_or(16 << 30) + }) +} + +/// Seed bytes currently resident on `device` across every source. +#[cfg(test)] +pub(crate) fn seed_cache_bytes(device: i32) -> usize { + SEED_CACHE_BYTES[usize::try_from(device).unwrap()].load(Ordering::Acquire) +} + +/// Seed cache uploads so far in the process. +#[cfg(test)] +pub(crate) static SEED_CACHE_UPLOADS: AtomicUsize = AtomicUsize::new(0); + +impl CudaTrace { + fn new( + spans: Vec, + height: usize, + real: usize, + width: usize, + retain_device_seeds: bool, + ) -> Self { + let mut offsets = Vec::with_capacity(spans.len() + 1); + let mut total = 0; + for span in &spans { + offsets.push(total); + total += span.bytes.len(); + } + offsets.push(total); + Self { + spans, + height, + real, + width, + offsets, + retain_device_seeds, + device_seeds: Mutex::new(Vec::new()), + } + } + + fn span_index(&self, row: usize) -> usize { + self.spans.partition_point(|s| s.first <= row).saturating_sub(1) + } + + fn span(&self, row: usize) -> &SeedSpan { + &self.spans[self.span_index(row)] + } + + fn seed_bytes(&self) -> usize { + *self.offsets.last().unwrap_or(&0) + } + + /// The device copy of all seed spans on `device`, uploaded on first use + /// within the cache limit; `None` serves the tile from the host instead. + /// The copy is one allocation, so the spans are uploaded together and + /// released together. + fn resident_seeds(&self, device: i32) -> Option<*const u8> { + if !self.retain_device_seeds || self.spans.is_empty() { + return None; + } + let mut cached = self.device_seeds.lock().unwrap(); + if let Some(seeds) = cached.iter_mut().find(|seeds| seeds.device == device) + { + seeds.hits += 1; + return Some(seeds.base); + } + let counter = SEED_CACHE_BYTES.get(usize::try_from(device).ok()?)?; + let bytes = self.seed_bytes(); + if counter + .fetch_update(Ordering::AcqRel, Ordering::Acquire, |held| { + (held + bytes <= seed_cache_limit()).then_some(held + bytes) + }) + .is_err() + { + tracing::debug!(device, bytes, "seed cache limit reached"); + // Refusals can recur per tile; count them without emitting tile events. + if tracing::enabled!(target: "prover_metrics", tracing::Level::INFO) { + SEED_CACHE_REFUSALS[device as usize].fetch_add(1, Ordering::Relaxed); + } + return None; + } + let pointers: Vec<*const u8> = + self.spans.iter().map(|span| span.bytes.as_ptr()).collect(); + let lengths: Vec = + self.spans.iter().map(|span| span.bytes.len()).collect(); + let mut base: *mut u8 = std::ptr::null_mut(); + let status = unsafe { + aiur_trace_seed_cache_upload( + device, + pointers.as_ptr(), + lengths.as_ptr(), + pointers.len(), + bytes, + &mut base, + ) + }; + if status != 0 { + counter.fetch_sub(bytes, Ordering::AcqRel); + tracing::debug!(device, bytes, status, "seed cache upload failed"); + tracing::info!(target: "prover_metrics", metric = "seed_cache", + device, action = "upload_failed", bytes); + return None; + } + tracing::debug!( + device, + bytes, + spans = pointers.len(), + "seed cache uploaded" + ); + #[cfg(test)] + SEED_CACHE_UPLOADS.fetch_add(1, Ordering::AcqRel); + tracing::info!(target: "prover_metrics", metric = "seed_cache", + device, action = "upload", bytes, spans = pointers.len()); + cached.push(DeviceSeeds { device, base, hits: 0 }); + Some(base) + } + + fn free_device_seeds(&self, keep: impl Fn(i32) -> bool) { + let mut cached = self.device_seeds.lock().unwrap(); + cached.retain(|seeds| { + if keep(seeds.device) { + return true; + } + let status = + unsafe { aiur_trace_seed_cache_free(seeds.device, seeds.base) }; + if status != 0 { + tracing::warn!( + device = seeds.device, + status, + "seed cache release failed" + ); + } + if let Some(counter) = + usize::try_from(seeds.device).ok().and_then(|d| SEED_CACHE_BYTES.get(d)) + { + counter.fetch_sub(self.seed_bytes(), Ordering::AcqRel); + } + tracing::info!(target: "prover_metrics", metric = "seed_cache", + device = seeds.device, action = "release", bytes = self.seed_bytes(), hits = seeds.hits); + false + }); + } +} + +impl Drop for CudaTrace { + fn drop(&mut self) { + self.free_device_seeds(|_| false); + } +} + +impl TraceGenerator for CudaTrace { + fn height(&self) -> usize { + self.height + } + fn width(&self) -> usize { + self.width + } + fn host_bytes(&self) -> usize { + self.spans.capacity() * size_of::() + + self.spans.iter().map(|s| s.bytes.capacity()).sum::() + } + fn write_rows(&self, first: usize, output: &mut [G]) { + assert_eq!(output.len() % self.width, 0); + let mut seed = Vec::new(); + let mut canonical = vec![0; self.width]; + let mut index = first % self.height; + for row in output.chunks_exact_mut(self.width) { + row.fill(G::ZERO); + if index < self.real { + let span = self.span(index); + seed.resize(span.writer.seed_words, 0); + let offset = (index - span.first) * span.stride; + span + .encoding + .decode( + span.writer.schema, + &span.bytes[offset..offset + span.stride], + &mut seed, + ) + .expect("validated seed"); + canonical.fill(0); + canonical[..span.writer.layout.input_size] + .copy_from_slice(&seed[1..1 + span.writer.layout.input_size]); + canonical[span.offsets.auxiliaries] = seed[0]; + (span.writer.write)(&seed, span.offsets, &mut canonical) + .expect("valid generated row"); + for (dst, &word) in row.iter_mut().zip(&canonical) { + *dst = G::from_u64(word); + } + } + index = (index + 1) % self.height; + } + } + fn write_device_rows( + &self, + output: DeviceTraceView<'_>, + ) -> Result<(), String> { + let _span = tracing::info_span!( + "aiur/codegen_device_rows", + device = output.device_id(), + first = output.first_row(), + rows = output.rows(), + width = self.width + ) + .entered(); + if output.width() != self.width { + return Err("CUDA trace width mismatch".into()); + } + let resident = self.resident_seeds(output.device_id()); + let mut done = 0; + let mut first = output.first_row() % self.height; + while done < output.rows() { + let index = self.span_index(first.min(self.real - 1)); + let span = &self.spans[index]; + let remaining = + (output.rows() - done).min(self.height - first).min(MAX_ROWS); + let (rows, real, seeds) = if first >= self.real { + (remaining, 0, std::ptr::null()) + } else { + let rows = remaining.min(span.first + span.rows - first); + let offset = (first - span.first) * span.stride; + let seeds = match resident { + Some(base) => unsafe { base.add(self.offsets[index] + offset) }, + None => span.bytes[offset..].as_ptr(), + }; + (rows, rows, seeds) + }; + let encoding = match span.encoding { + SeedEncoding::Canonical => 0, + SeedEncoding::Typed => 1, + }; + let status = unsafe { + (span.kernel)( + output.device_id(), + seeds, + encoding, + real, + rows, + self.width, + span.offsets.selectors, + span.offsets.auxiliaries, + output.as_mut_ptr().add(done * self.width), + ) + }; + if status != 0 { + return Err(format!( + "generated CUDA function {}, row {first}: status {status}", + span.function + )); + } + done += rows; + first = (first + rows) % self.height; + } + Ok(()) + } + fn release_device(&self, device_id: i32) { + self.free_device_seeds(|device| device != device_id); + } +} + +unsafe extern "C" { + fn aiur_trace_seed_cache_upload( + device: i32, + spans: *const *const u8, + lengths: *const usize, + count: usize, + total: usize, + cached: *mut *mut u8, + ) -> i32; + fn aiur_trace_seed_cache_free(device: i32, cached: *mut u8) -> i32; + fn aiur_trace_memory( + device: i32, + seeds: *const u8, + values: usize, + real: usize, + rows: usize, + output: *mut u64, + ) -> i32; +} + +/// One memory table range as `[multiplicity, 1, pointer, values]` rows, built +/// on the device from `[multiplicity, pointer, values]` seeds. The seeds are +/// canonical words copied out of the record, so no packer runs; every table +/// row is real, zero multiplicities included, exactly as the CPU builder +/// emits them. +pub struct MemoryTrace { + values: usize, + spans: Vec, + height: usize, + real: usize, +} + +struct MemorySpan { + first: usize, + rows: usize, + bytes: Vec, +} + +impl MemoryTrace { + fn stride(&self) -> usize { + 8 * (self.values + 2) + } + + fn span(&self, row: usize) -> &MemorySpan { + let index = + self.spans.partition_point(|s| s.first <= row).saturating_sub(1); + &self.spans[index] + } +} + +/// The width-`size` table's rows at table indices `range`, row `i` carrying +/// pointer `record.pointer_base + range.start + i`. An empty range is the CPU +/// builder's case: it yields an empty trace that the prover deactivates. +pub fn prepare_memory( + record: &QueryRecord, + size: usize, + slots: &[usize], + range: std::ops::Range, +) -> TraceResult<(TraceSource, LookupValues)> { + let _span = + tracing::info_span!("aiur/codegen_memory_seeds", size, rows = range.len()) + .entered(); + let queries = record.memory_queries.get(&size).ok_or_else(|| { + error(0, None, "record has no memory table of this width") + })?; + if range.is_empty() || range.end > queries.len() { + return Err(error(0, None, "invalid memory table range")); + } + let stride = 8 * (size + 2); + if stride > MAX_SEED_BYTES { + return Err(error(0, None, "memory seed exceeds the upload limit")); + } + let per_span = MAX_ROWS.min(MAX_SEED_BYTES / stride); + let count = range.len(); + let spans: Vec = (0..count) + .step_by(per_span) + .collect::>() + .into_par_iter() + .map(|first| { + let rows = per_span.min(count - first); + let mut bytes = vec![0; rows * stride]; + for (i, seed) in bytes.chunks_exact_mut(stride).enumerate() { + let index = range.start + first + i; + let (values, result) = + queries.get_index(index).expect("table index in range"); + let pointer = G::from_usize(record.pointer_base + index); + seed[..8].copy_from_slice( + &result.multiplicity.as_canonical_u64().to_le_bytes(), + ); + seed[8..16].copy_from_slice(&pointer.as_canonical_u64().to_le_bytes()); + for (dst, value) in seed[16..].chunks_exact_mut(8).zip(values) { + dst.copy_from_slice(&value.as_canonical_u64().to_le_bytes()); + } + } + MemorySpan { first, rows, bytes } + }) + .collect(); + let height = count + .checked_next_power_of_two() + .ok_or_else(|| error(0, None, "trace height overflow"))?; + tracing::debug!( + size, + rows = count, + seed_bytes = count * stride, + seed_spans = spans.len(), + "prepared generated memory trace" + ); + Ok(( + TraceSource::Generated(Arc::new(MemoryTrace { + values: size, + spans, + height, + real: count, + })), + LookupValues::shape_only(height, slots), + )) +} + +impl TraceGenerator for MemoryTrace { + fn height(&self) -> usize { + self.height + } + fn width(&self) -> usize { + self.values + 3 + } + fn host_bytes(&self) -> usize { + self.spans.capacity() * size_of::() + + self.spans.iter().map(|s| s.bytes.capacity()).sum::() + } + fn write_rows(&self, first: usize, output: &mut [G]) { + let width = self.width(); + assert_eq!(output.len() % width, 0); + let stride = self.stride(); + let mut index = first % self.height; + for row in output.chunks_exact_mut(width) { + row.fill(G::ZERO); + if index < self.real { + let span = self.span(index); + let offset = (index - span.first) * stride; + let seed = &span.bytes[offset..offset + stride]; + let word = |i: usize| { + G::from_u64(u64::from_le_bytes( + seed[8 * i..8 * i + 8].try_into().expect("eight bytes"), + )) + }; + row[0] = word(0); + row[1] = G::ONE; + row[2] = word(1); + for (i, cell) in row[3..].iter_mut().enumerate() { + *cell = word(2 + i); + } + } + index = (index + 1) % self.height; + } + } + fn write_device_rows( + &self, + output: DeviceTraceView<'_>, + ) -> Result<(), String> { + let _span = tracing::info_span!( + "aiur/codegen_memory_rows", + device = output.device_id(), + first = output.first_row(), + rows = output.rows(), + width = self.width() + ) + .entered(); + if output.width() != self.width() { + return Err("memory trace width mismatch".into()); + } + let stride = self.stride(); + let mut done = 0; + let mut first = output.first_row() % self.height; + while done < output.rows() { + let span = self.span(first.min(self.real - 1)); + let remaining = + (output.rows() - done).min(self.height - first).min(MAX_ROWS); + let (rows, real, seeds) = if first >= self.real { + (remaining, 0, std::ptr::null()) + } else { + let rows = remaining.min(span.first + span.rows - first); + let offset = (first - span.first) * stride; + (rows, rows, span.bytes[offset..].as_ptr()) + }; + let status = unsafe { + aiur_trace_memory( + output.device_id(), + seeds, + self.values, + real, + rows, + output.as_mut_ptr().add(done * self.width()), + ) + }; + if status != 0 { + return Err(format!( + "generated memory table of width {}, row {first}: status {status}", + self.values + )); + } + done += rows; + first = (first + rows) % self.height; + } + Ok(()) + } +} diff --git a/crates/aiur/src/trace_codegen/programs/ix_aggr.rs b/crates/aiur/src/trace_codegen/programs/ix_aggr.rs new file mode 100644 index 000000000..6f3298d3c --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ix_aggr.rs @@ -0,0 +1,1929 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_86(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_86_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn pack_86_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; let [v_470]: [G; 1] = [v_462 + v_465]; let [v_471]: [G; 1] = [v_464 + v_467]; let [v_472]: [G; 1] = [v_466 + v_469]; let [v_473]: [G; 1] = [v_468 + v_463]; let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; let [v_532]: [G; 1] = [v_524 + v_527]; let [v_533]: [G; 1] = [v_526 + v_529]; let [v_534]: [G; 1] = [v_528 + v_531]; let [v_535]: [G; 1] = [v_530 + v_525]; let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; let [v_594]: [G; 1] = [v_586 + v_589]; let [v_595]: [G; 1] = [v_588 + v_591]; let [v_596]: [G; 1] = [v_590 + v_593]; let [v_597]: [G; 1] = [v_592 + v_587]; let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; let [v_656]: [G; 1] = [v_648 + v_651]; let [v_657]: [G; 1] = [v_650 + v_653]; let [v_658]: [G; 1] = [v_652 + v_655]; let [v_659]: [G; 1] = [v_654 + v_649]; let [v_660]: [G; 1] = [v_0 + v_166]; let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.check_returned::<32>(436, 86, &[v_660, v_443, v_444, v_445, v_446, v_505, v_506, v_507, v_508, v_567, v_568, v_569, v_570, v_629, v_630, v_631, v_632, v_656, v_657, v_658, v_659, v_470, v_471, v_472, v_473, v_532, v_533, v_534, v_535, v_594, v_595, v_596, v_597, v_580, v_581, v_582, v_583, v_642, v_643, v_644, v_645, v_456, v_457, v_458, v_459, v_518, v_519, v_520, v_521, v_515, v_516, v_517, v_514, v_577, v_578, v_579, v_576, v_639, v_640, v_641, v_638, v_453, v_454, v_455, v_452, 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])?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn write_86(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_86: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_117(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 116, &[v_0, v_1])?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(2, v_4)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed[58] = v_58.as_canonical_u64(); seed[59] = v_59.as_canonical_u64(); seed[60] = v_60.as_canonical_u64(); seed[61] = v_61.as_canonical_u64(); seed[62] = v_62.as_canonical_u64(); seed[63] = v_63.as_canonical_u64(); seed[64] = v_64.as_canonical_u64(); seed[65] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(21, 86, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed[66] = v_82.as_canonical_u64(); seed[67] = v_83.as_canonical_u64(); seed[68] = v_84.as_canonical_u64(); seed[69] = v_85.as_canonical_u64(); seed[70] = v_86.as_canonical_u64(); seed[71] = v_87.as_canonical_u64(); seed[72] = v_88.as_canonical_u64(); seed[73] = v_89.as_canonical_u64(); seed[74] = v_90.as_canonical_u64(); seed[75] = v_91.as_canonical_u64(); seed[76] = v_92.as_canonical_u64(); seed[77] = v_93.as_canonical_u64(); seed[78] = v_94.as_canonical_u64(); seed[79] = v_95.as_canonical_u64(); seed[80] = v_96.as_canonical_u64(); seed[81] = v_97.as_canonical_u64(); seed[82] = v_98.as_canonical_u64(); seed[83] = v_99.as_canonical_u64(); seed[84] = v_100.as_canonical_u64(); seed[85] = v_101.as_canonical_u64(); seed[86] = v_102.as_canonical_u64(); seed[87] = v_103.as_canonical_u64(); seed[88] = v_104.as_canonical_u64(); seed[89] = v_105.as_canonical_u64(); seed[90] = v_106.as_canonical_u64(); seed[91] = v_107.as_canonical_u64(); seed[92] = v_108.as_canonical_u64(); seed[93] = v_109.as_canonical_u64(); seed[94] = v_110.as_canonical_u64(); seed[95] = v_111.as_canonical_u64(); seed[96] = v_112.as_canonical_u64(); seed[97] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, 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])?; seed[98] = v_114.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 116, &[v_14, v_15])?; seed[18] = v_115.as_canonical_u64(); seed[19] = v_116.as_canonical_u64(); seed[20] = v_117.as_canonical_u64(); seed[21] = v_118.as_canonical_u64(); seed[22] = v_119.as_canonical_u64(); seed[23] = v_120.as_canonical_u64(); seed[24] = v_121.as_canonical_u64(); seed[25] = v_122.as_canonical_u64(); seed[26] = v_123.as_canonical_u64(); seed[27] = v_124.as_canonical_u64(); seed[28] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 116, &[v_123, v_124])?; seed[29] = v_126.as_canonical_u64(); seed[30] = v_127.as_canonical_u64(); seed[31] = v_128.as_canonical_u64(); seed[32] = v_129.as_canonical_u64(); seed[33] = v_130.as_canonical_u64(); seed[34] = v_131.as_canonical_u64(); seed[35] = v_132.as_canonical_u64(); seed[36] = v_133.as_canonical_u64(); seed[37] = v_134.as_canonical_u64(); seed[38] = v_135.as_canonical_u64(); seed[39] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 116, &[v_134, v_135])?; seed[40] = v_137.as_canonical_u64(); seed[41] = v_138.as_canonical_u64(); seed[42] = v_139.as_canonical_u64(); seed[43] = v_140.as_canonical_u64(); seed[44] = v_141.as_canonical_u64(); seed[45] = v_142.as_canonical_u64(); seed[46] = v_143.as_canonical_u64(); seed[47] = v_144.as_canonical_u64(); seed[48] = v_145.as_canonical_u64(); seed[49] = v_146.as_canonical_u64(); seed[50] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 116, &[v_145, v_146])?; seed[51] = v_148.as_canonical_u64(); seed[52] = v_149.as_canonical_u64(); seed[53] = v_150.as_canonical_u64(); seed[54] = v_151.as_canonical_u64(); seed[55] = v_152.as_canonical_u64(); seed[56] = v_153.as_canonical_u64(); seed[57] = v_154.as_canonical_u64(); seed[58] = v_155.as_canonical_u64(); seed[59] = v_156.as_canonical_u64(); seed[60] = v_157.as_canonical_u64(); seed[61] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 116, &[v_156, v_157])?; seed[62] = v_159.as_canonical_u64(); seed[63] = v_160.as_canonical_u64(); seed[64] = v_161.as_canonical_u64(); seed[65] = v_162.as_canonical_u64(); seed[66] = v_163.as_canonical_u64(); seed[67] = v_164.as_canonical_u64(); seed[68] = v_165.as_canonical_u64(); seed[69] = v_166.as_canonical_u64(); seed[70] = v_167.as_canonical_u64(); seed[71] = v_168.as_canonical_u64(); seed[72] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 116, &[v_167, v_168])?; seed[73] = v_170.as_canonical_u64(); seed[74] = v_171.as_canonical_u64(); seed[75] = v_172.as_canonical_u64(); seed[76] = v_173.as_canonical_u64(); seed[77] = v_174.as_canonical_u64(); seed[78] = v_175.as_canonical_u64(); seed[79] = v_176.as_canonical_u64(); seed[80] = v_177.as_canonical_u64(); seed[81] = v_178.as_canonical_u64(); seed[82] = v_179.as_canonical_u64(); seed[83] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 116, &[v_178, v_179])?; seed[84] = v_181.as_canonical_u64(); seed[85] = v_182.as_canonical_u64(); seed[86] = v_183.as_canonical_u64(); seed[87] = v_184.as_canonical_u64(); seed[88] = v_185.as_canonical_u64(); seed[89] = v_186.as_canonical_u64(); seed[90] = v_187.as_canonical_u64(); seed[91] = v_188.as_canonical_u64(); seed[92] = v_189.as_canonical_u64(); seed[93] = v_190.as_canonical_u64(); seed[94] = v_191.as_canonical_u64(); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed[95] = v_201.as_canonical_u64(); seed[96] = v_202.as_canonical_u64(); seed[97] = v_203.as_canonical_u64(); seed[98] = v_204.as_canonical_u64(); seed[99] = v_205.as_canonical_u64(); seed[100] = v_206.as_canonical_u64(); seed[101] = v_207.as_canonical_u64(); seed[102] = v_208.as_canonical_u64(); seed[103] = v_209.as_canonical_u64(); seed[104] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed[105] = v_211.as_canonical_u64(); seed[106] = v_212.as_canonical_u64(); seed[107] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed[108] = v_225.as_canonical_u64(); seed[109] = v_226.as_canonical_u64(); seed[110] = v_227.as_canonical_u64(); seed[111] = v_228.as_canonical_u64(); seed[112] = v_229.as_canonical_u64(); seed[113] = v_230.as_canonical_u64(); seed[114] = v_231.as_canonical_u64(); seed[115] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = context.call::<1>(52, 4, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed[116] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed[117] = v_241.as_canonical_u64(); seed[118] = v_242.as_canonical_u64(); seed[119] = v_243.as_canonical_u64(); seed[120] = v_244.as_canonical_u64(); seed[121] = v_245.as_canonical_u64(); seed[122] = v_246.as_canonical_u64(); seed[123] = v_247.as_canonical_u64(); seed[124] = v_248.as_canonical_u64(); seed[125] = v_249.as_canonical_u64(); seed[126] = v_250.as_canonical_u64(); seed[127] = v_251.as_canonical_u64(); seed[128] = v_252.as_canonical_u64(); seed[129] = v_253.as_canonical_u64(); seed[130] = v_254.as_canonical_u64(); seed[131] = v_255.as_canonical_u64(); seed[132] = v_256.as_canonical_u64(); seed[133] = v_257.as_canonical_u64(); seed[134] = v_258.as_canonical_u64(); seed[135] = v_259.as_canonical_u64(); seed[136] = v_260.as_canonical_u64(); seed[137] = v_261.as_canonical_u64(); seed[138] = v_262.as_canonical_u64(); seed[139] = v_263.as_canonical_u64(); seed[140] = v_264.as_canonical_u64(); seed[141] = v_265.as_canonical_u64(); seed[142] = v_266.as_canonical_u64(); seed[143] = v_267.as_canonical_u64(); seed[144] = v_268.as_canonical_u64(); seed[145] = v_269.as_canonical_u64(); seed[146] = v_270.as_canonical_u64(); seed[147] = v_271.as_canonical_u64(); seed[148] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 86, &[v_288, 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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed[149] = v_289.as_canonical_u64(); seed[150] = v_290.as_canonical_u64(); seed[151] = v_291.as_canonical_u64(); seed[152] = v_292.as_canonical_u64(); seed[153] = v_293.as_canonical_u64(); seed[154] = v_294.as_canonical_u64(); seed[155] = v_295.as_canonical_u64(); seed[156] = v_296.as_canonical_u64(); seed[157] = v_297.as_canonical_u64(); seed[158] = v_298.as_canonical_u64(); seed[159] = v_299.as_canonical_u64(); seed[160] = v_300.as_canonical_u64(); seed[161] = v_301.as_canonical_u64(); seed[162] = v_302.as_canonical_u64(); seed[163] = v_303.as_canonical_u64(); seed[164] = v_304.as_canonical_u64(); seed[165] = v_305.as_canonical_u64(); seed[166] = v_306.as_canonical_u64(); seed[167] = v_307.as_canonical_u64(); seed[168] = v_308.as_canonical_u64(); seed[169] = v_309.as_canonical_u64(); seed[170] = v_310.as_canonical_u64(); seed[171] = v_311.as_canonical_u64(); seed[172] = v_312.as_canonical_u64(); seed[173] = v_313.as_canonical_u64(); seed[174] = v_314.as_canonical_u64(); seed[175] = v_315.as_canonical_u64(); seed[176] = v_316.as_canonical_u64(); seed[177] = v_317.as_canonical_u64(); seed[178] = v_318.as_canonical_u64(); seed[179] = v_319.as_canonical_u64(); seed[180] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_322.as_canonical_u64(); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed[181] = v_355.as_canonical_u64(); seed[182] = v_356.as_canonical_u64(); seed[183] = v_357.as_canonical_u64(); seed[184] = v_358.as_canonical_u64(); seed[185] = v_359.as_canonical_u64(); seed[186] = v_360.as_canonical_u64(); seed[187] = v_361.as_canonical_u64(); seed[188] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 13, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed[189] = v_363.as_canonical_u64(); seed[190] = v_364.as_canonical_u64(); seed[191] = v_365.as_canonical_u64(); seed[192] = v_366.as_canonical_u64(); seed[193] = v_367.as_canonical_u64(); seed[194] = v_368.as_canonical_u64(); seed[195] = v_369.as_canonical_u64(); seed[196] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed[197] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed[198] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[199] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed[200] = v_374.as_canonical_u64(); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed[182] = v_378.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn pack_117_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 116, &[v_0, v_1])?; seed.u8(404, v_6); seed.u8(405, v_7); seed.u8(406, v_8); seed.u8(407, v_9); seed.u8(408, v_10); seed.u8(409, v_11); seed.u8(410, v_12); seed.u8(411, v_13); seed.u32(328, v_14); seed.u32(332, v_15); seed.u8(412, v_16); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed.full(24, v_17); seed.full(32, v_18); seed.full(40, v_19); seed.full(48, v_20); seed.full(56, v_21); seed.full(64, v_22); seed.full(72, v_23); seed.full(80, v_24); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(2, v_4)?; seed.u32(336, v_25); seed.u32(340, v_26); seed.u8(413, v_27); seed.u8(414, v_28); seed.u8(415, v_29); seed.u8(416, v_30); seed.u8(417, v_31); seed.u8(418, v_32); seed.u8(419, v_33); seed.u8(420, v_34); seed.u8(421, v_35); seed.u32(344, v_36); seed.u32(348, v_37); seed.u8(422, v_38); seed.u8(423, v_39); seed.u8(424, v_40); seed.u8(425, v_41); seed.u8(426, v_42); seed.u8(427, v_43); seed.u8(428, v_44); seed.u8(429, v_45); seed.u8(430, v_46); seed.u32(352, v_47); seed.u32(356, v_48); seed.u8(431, v_49); seed.u8(432, v_50); seed.u8(433, v_51); seed.u8(434, v_52); seed.u8(435, v_53); seed.u8(436, v_54); seed.u8(437, v_55); seed.u8(438, v_56); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed.u8(439, v_58); seed.u32(360, v_59); seed.u32(364, v_60); seed.u8(440, v_61); seed.u8(441, v_62); seed.u8(442, v_63); seed.u8(443, v_64); seed.u8(444, v_65); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(21, 86, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed.u8(445, v_82); seed.u8(446, v_83); seed.u8(447, v_84); seed.u8(448, v_85); seed.u32(368, v_86); seed.u32(372, v_87); seed.u8(449, v_88); seed.u8(450, v_89); seed.u8(451, v_90); seed.u8(452, v_91); seed.u8(453, v_92); seed.u8(454, v_93); seed.u8(455, v_94); seed.u8(456, v_95); seed.u8(457, v_96); seed.u32(376, v_97); seed.u32(380, v_98); seed.u8(458, v_99); seed.u8(459, v_100); seed.u8(460, v_101); seed.u8(461, v_102); seed.u8(462, v_103); seed.u8(463, v_104); seed.u8(464, v_105); seed.u8(465, v_106); seed.u8(466, v_107); seed.u32(384, v_108); seed.u32(388, v_109); seed.u8(467, v_110); seed.u8(468, v_111); seed.full(88, v_112); seed.full(96, v_113); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, 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])?; seed.full(104, v_114); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 116, &[v_14, v_15])?; seed.full(24, v_115); seed.full(32, v_116); seed.full(40, v_117); seed.full(48, v_118); seed.full(56, v_119); seed.full(64, v_120); seed.full(72, v_121); seed.full(80, v_122); seed.u32(336, v_123); seed.u32(340, v_124); seed.u8(413, v_125); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 116, &[v_123, v_124])?; seed.u8(414, v_126); seed.u8(415, v_127); seed.u8(416, v_128); seed.u8(417, v_129); seed.u8(418, v_130); seed.u8(419, v_131); seed.u8(420, v_132); seed.u8(421, v_133); seed.u32(344, v_134); seed.u32(348, v_135); seed.u8(422, v_136); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 116, &[v_134, v_135])?; seed.u8(423, v_137); seed.u8(424, v_138); seed.u8(425, v_139); seed.u8(426, v_140); seed.u8(427, v_141); seed.u8(428, v_142); seed.u8(429, v_143); seed.u8(430, v_144); seed.u32(352, v_145); seed.u32(356, v_146); seed.u8(431, v_147); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 116, &[v_145, v_146])?; seed.u8(432, v_148); seed.u8(433, v_149); seed.u8(434, v_150); seed.u8(435, v_151); seed.u8(436, v_152); seed.u8(437, v_153); seed.u8(438, v_154); seed.u8(439, v_155); seed.u32(360, v_156); seed.u32(364, v_157); seed.u8(440, v_158); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 116, &[v_156, v_157])?; seed.u8(441, v_159); seed.u8(442, v_160); seed.u8(443, v_161); seed.u8(444, v_162); seed.u8(445, v_163); seed.u8(446, v_164); seed.u8(447, v_165); seed.u8(448, v_166); seed.u32(368, v_167); seed.u32(372, v_168); seed.u8(449, v_169); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 116, &[v_167, v_168])?; seed.u8(450, v_170); seed.u8(451, v_171); seed.u8(452, v_172); seed.u8(453, v_173); seed.u8(454, v_174); seed.u8(455, v_175); seed.u8(456, v_176); seed.u8(457, v_177); seed.u32(376, v_178); seed.u32(380, v_179); seed.u8(458, v_180); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 116, &[v_178, v_179])?; seed.u8(459, v_181); seed.u8(460, v_182); seed.u8(461, v_183); seed.u8(462, v_184); seed.u8(463, v_185); seed.u8(464, v_186); seed.u8(465, v_187); seed.u8(466, v_188); seed.u32(384, v_189); seed.u32(388, v_190); seed.u8(467, v_191); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed.u8(468, v_201); seed.full(88, v_202); seed.full(96, v_203); seed.full(104, v_204); seed.full(112, v_205); seed.full(120, v_206); seed.full(128, v_207); seed.full(136, v_208); seed.full(144, v_209); seed.full(152, v_210); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed.u8(469, v_211); seed.full(160, v_212); seed.full(168, v_213); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed.u8(470, v_225); seed.u8(471, v_226); seed.u8(472, v_227); seed.u8(473, v_228); seed.u8(474, v_229); seed.u8(475, v_230); seed.u8(476, v_231); seed.u8(477, v_232); let [v_233]: [G; 1] = context.call::<1>(52, 4, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed.u8(478, v_233); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed.u8(479, v_241); seed.u8(480, v_242); seed.u8(481, v_243); seed.u8(482, v_244); seed.u8(483, v_245); seed.u8(484, v_246); seed.u8(485, v_247); seed.u8(486, v_248); seed.u8(487, v_249); seed.u8(488, v_250); seed.u8(489, v_251); seed.u8(490, v_252); seed.u8(491, v_253); seed.u8(492, v_254); seed.u8(493, v_255); seed.u8(494, v_256); seed.u8(495, v_257); seed.u8(496, v_258); seed.u8(497, v_259); seed.u8(498, v_260); seed.u8(499, v_261); seed.u8(500, v_262); seed.u8(501, v_263); seed.u8(502, v_264); seed.u8(503, v_265); seed.u8(504, v_266); seed.u8(505, v_267); seed.u8(506, v_268); seed.u8(507, v_269); seed.u8(508, v_270); seed.u8(509, v_271); seed.u8(510, v_272); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 86, &[v_288, 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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed.u8(511, v_289); seed.u8(512, v_290); seed.u8(513, v_291); seed.u8(514, v_292); seed.u8(515, v_293); seed.u8(516, v_294); seed.u8(517, v_295); seed.u8(518, v_296); seed.u8(519, v_297); seed.u8(520, v_298); seed.u8(521, v_299); seed.u8(522, v_300); seed.u8(523, v_301); seed.u8(524, v_302); seed.u8(525, v_303); seed.u8(526, v_304); seed.u8(527, v_305); seed.u8(528, v_306); seed.u8(529, v_307); seed.u8(530, v_308); seed.u8(531, v_309); seed.u8(532, v_310); seed.u8(533, v_311); seed.u8(534, v_312); seed.u8(535, v_313); seed.u8(536, v_314); seed.u8(537, v_315); seed.u8(538, v_316); seed.u8(539, v_317); seed.u8(540, v_318); seed.u8(541, v_319); seed.u8(542, v_320); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_322); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed.full(176, v_355); seed.full(184, v_356); seed.full(192, v_357); seed.full(200, v_358); seed.full(208, v_359); seed.full(216, v_360); seed.full(224, v_361); seed.full(232, v_362); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 13, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed.full(240, v_363); seed.full(248, v_364); seed.full(256, v_365); seed.full(264, v_366); seed.full(272, v_367); seed.full(280, v_368); seed.full(288, v_369); seed.full(296, v_370); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed.u32(392, v_371); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed.u32(396, v_372); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.u32(400, v_373); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed.full(304, v_374); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_377); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed.full(184, v_378); Ok(()) }, } }, } }, } } + +fn pack_117_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 116, &[v_0, v_1])?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(2, v_4)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed[58] = v_58.as_canonical_u64(); seed[59] = v_59.as_canonical_u64(); seed[60] = v_60.as_canonical_u64(); seed[61] = v_61.as_canonical_u64(); seed[62] = v_62.as_canonical_u64(); seed[63] = v_63.as_canonical_u64(); seed[64] = v_64.as_canonical_u64(); seed[65] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(21, 86, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed[66] = v_82.as_canonical_u64(); seed[67] = v_83.as_canonical_u64(); seed[68] = v_84.as_canonical_u64(); seed[69] = v_85.as_canonical_u64(); seed[70] = v_86.as_canonical_u64(); seed[71] = v_87.as_canonical_u64(); seed[72] = v_88.as_canonical_u64(); seed[73] = v_89.as_canonical_u64(); seed[74] = v_90.as_canonical_u64(); seed[75] = v_91.as_canonical_u64(); seed[76] = v_92.as_canonical_u64(); seed[77] = v_93.as_canonical_u64(); seed[78] = v_94.as_canonical_u64(); seed[79] = v_95.as_canonical_u64(); seed[80] = v_96.as_canonical_u64(); seed[81] = v_97.as_canonical_u64(); seed[82] = v_98.as_canonical_u64(); seed[83] = v_99.as_canonical_u64(); seed[84] = v_100.as_canonical_u64(); seed[85] = v_101.as_canonical_u64(); seed[86] = v_102.as_canonical_u64(); seed[87] = v_103.as_canonical_u64(); seed[88] = v_104.as_canonical_u64(); seed[89] = v_105.as_canonical_u64(); seed[90] = v_106.as_canonical_u64(); seed[91] = v_107.as_canonical_u64(); seed[92] = v_108.as_canonical_u64(); seed[93] = v_109.as_canonical_u64(); seed[94] = v_110.as_canonical_u64(); seed[95] = v_111.as_canonical_u64(); seed[96] = v_112.as_canonical_u64(); seed[97] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, 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])?; seed[98] = v_114.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 116, &[v_14, v_15])?; seed[18] = v_115.as_canonical_u64(); seed[19] = v_116.as_canonical_u64(); seed[20] = v_117.as_canonical_u64(); seed[21] = v_118.as_canonical_u64(); seed[22] = v_119.as_canonical_u64(); seed[23] = v_120.as_canonical_u64(); seed[24] = v_121.as_canonical_u64(); seed[25] = v_122.as_canonical_u64(); seed[26] = v_123.as_canonical_u64(); seed[27] = v_124.as_canonical_u64(); seed[28] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 116, &[v_123, v_124])?; seed[29] = v_126.as_canonical_u64(); seed[30] = v_127.as_canonical_u64(); seed[31] = v_128.as_canonical_u64(); seed[32] = v_129.as_canonical_u64(); seed[33] = v_130.as_canonical_u64(); seed[34] = v_131.as_canonical_u64(); seed[35] = v_132.as_canonical_u64(); seed[36] = v_133.as_canonical_u64(); seed[37] = v_134.as_canonical_u64(); seed[38] = v_135.as_canonical_u64(); seed[39] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 116, &[v_134, v_135])?; seed[40] = v_137.as_canonical_u64(); seed[41] = v_138.as_canonical_u64(); seed[42] = v_139.as_canonical_u64(); seed[43] = v_140.as_canonical_u64(); seed[44] = v_141.as_canonical_u64(); seed[45] = v_142.as_canonical_u64(); seed[46] = v_143.as_canonical_u64(); seed[47] = v_144.as_canonical_u64(); seed[48] = v_145.as_canonical_u64(); seed[49] = v_146.as_canonical_u64(); seed[50] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 116, &[v_145, v_146])?; seed[51] = v_148.as_canonical_u64(); seed[52] = v_149.as_canonical_u64(); seed[53] = v_150.as_canonical_u64(); seed[54] = v_151.as_canonical_u64(); seed[55] = v_152.as_canonical_u64(); seed[56] = v_153.as_canonical_u64(); seed[57] = v_154.as_canonical_u64(); seed[58] = v_155.as_canonical_u64(); seed[59] = v_156.as_canonical_u64(); seed[60] = v_157.as_canonical_u64(); seed[61] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 116, &[v_156, v_157])?; seed[62] = v_159.as_canonical_u64(); seed[63] = v_160.as_canonical_u64(); seed[64] = v_161.as_canonical_u64(); seed[65] = v_162.as_canonical_u64(); seed[66] = v_163.as_canonical_u64(); seed[67] = v_164.as_canonical_u64(); seed[68] = v_165.as_canonical_u64(); seed[69] = v_166.as_canonical_u64(); seed[70] = v_167.as_canonical_u64(); seed[71] = v_168.as_canonical_u64(); seed[72] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 116, &[v_167, v_168])?; seed[73] = v_170.as_canonical_u64(); seed[74] = v_171.as_canonical_u64(); seed[75] = v_172.as_canonical_u64(); seed[76] = v_173.as_canonical_u64(); seed[77] = v_174.as_canonical_u64(); seed[78] = v_175.as_canonical_u64(); seed[79] = v_176.as_canonical_u64(); seed[80] = v_177.as_canonical_u64(); seed[81] = v_178.as_canonical_u64(); seed[82] = v_179.as_canonical_u64(); seed[83] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 116, &[v_178, v_179])?; seed[84] = v_181.as_canonical_u64(); seed[85] = v_182.as_canonical_u64(); seed[86] = v_183.as_canonical_u64(); seed[87] = v_184.as_canonical_u64(); seed[88] = v_185.as_canonical_u64(); seed[89] = v_186.as_canonical_u64(); seed[90] = v_187.as_canonical_u64(); seed[91] = v_188.as_canonical_u64(); seed[92] = v_189.as_canonical_u64(); seed[93] = v_190.as_canonical_u64(); seed[94] = v_191.as_canonical_u64(); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed[95] = v_201.as_canonical_u64(); seed[96] = v_202.as_canonical_u64(); seed[97] = v_203.as_canonical_u64(); seed[98] = v_204.as_canonical_u64(); seed[99] = v_205.as_canonical_u64(); seed[100] = v_206.as_canonical_u64(); seed[101] = v_207.as_canonical_u64(); seed[102] = v_208.as_canonical_u64(); seed[103] = v_209.as_canonical_u64(); seed[104] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed[105] = v_211.as_canonical_u64(); seed[106] = v_212.as_canonical_u64(); seed[107] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed[108] = v_225.as_canonical_u64(); seed[109] = v_226.as_canonical_u64(); seed[110] = v_227.as_canonical_u64(); seed[111] = v_228.as_canonical_u64(); seed[112] = v_229.as_canonical_u64(); seed[113] = v_230.as_canonical_u64(); seed[114] = v_231.as_canonical_u64(); seed[115] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = context.call::<1>(52, 4, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed[116] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed[117] = v_241.as_canonical_u64(); seed[118] = v_242.as_canonical_u64(); seed[119] = v_243.as_canonical_u64(); seed[120] = v_244.as_canonical_u64(); seed[121] = v_245.as_canonical_u64(); seed[122] = v_246.as_canonical_u64(); seed[123] = v_247.as_canonical_u64(); seed[124] = v_248.as_canonical_u64(); seed[125] = v_249.as_canonical_u64(); seed[126] = v_250.as_canonical_u64(); seed[127] = v_251.as_canonical_u64(); seed[128] = v_252.as_canonical_u64(); seed[129] = v_253.as_canonical_u64(); seed[130] = v_254.as_canonical_u64(); seed[131] = v_255.as_canonical_u64(); seed[132] = v_256.as_canonical_u64(); seed[133] = v_257.as_canonical_u64(); seed[134] = v_258.as_canonical_u64(); seed[135] = v_259.as_canonical_u64(); seed[136] = v_260.as_canonical_u64(); seed[137] = v_261.as_canonical_u64(); seed[138] = v_262.as_canonical_u64(); seed[139] = v_263.as_canonical_u64(); seed[140] = v_264.as_canonical_u64(); seed[141] = v_265.as_canonical_u64(); seed[142] = v_266.as_canonical_u64(); seed[143] = v_267.as_canonical_u64(); seed[144] = v_268.as_canonical_u64(); seed[145] = v_269.as_canonical_u64(); seed[146] = v_270.as_canonical_u64(); seed[147] = v_271.as_canonical_u64(); seed[148] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 86, &[v_288, 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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed[149] = v_289.as_canonical_u64(); seed[150] = v_290.as_canonical_u64(); seed[151] = v_291.as_canonical_u64(); seed[152] = v_292.as_canonical_u64(); seed[153] = v_293.as_canonical_u64(); seed[154] = v_294.as_canonical_u64(); seed[155] = v_295.as_canonical_u64(); seed[156] = v_296.as_canonical_u64(); seed[157] = v_297.as_canonical_u64(); seed[158] = v_298.as_canonical_u64(); seed[159] = v_299.as_canonical_u64(); seed[160] = v_300.as_canonical_u64(); seed[161] = v_301.as_canonical_u64(); seed[162] = v_302.as_canonical_u64(); seed[163] = v_303.as_canonical_u64(); seed[164] = v_304.as_canonical_u64(); seed[165] = v_305.as_canonical_u64(); seed[166] = v_306.as_canonical_u64(); seed[167] = v_307.as_canonical_u64(); seed[168] = v_308.as_canonical_u64(); seed[169] = v_309.as_canonical_u64(); seed[170] = v_310.as_canonical_u64(); seed[171] = v_311.as_canonical_u64(); seed[172] = v_312.as_canonical_u64(); seed[173] = v_313.as_canonical_u64(); seed[174] = v_314.as_canonical_u64(); seed[175] = v_315.as_canonical_u64(); seed[176] = v_316.as_canonical_u64(); seed[177] = v_317.as_canonical_u64(); seed[178] = v_318.as_canonical_u64(); seed[179] = v_319.as_canonical_u64(); seed[180] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_322.as_canonical_u64(); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed[181] = v_355.as_canonical_u64(); seed[182] = v_356.as_canonical_u64(); seed[183] = v_357.as_canonical_u64(); seed[184] = v_358.as_canonical_u64(); seed[185] = v_359.as_canonical_u64(); seed[186] = v_360.as_canonical_u64(); seed[187] = v_361.as_canonical_u64(); seed[188] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 13, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed[189] = v_363.as_canonical_u64(); seed[190] = v_364.as_canonical_u64(); seed[191] = v_365.as_canonical_u64(); seed[192] = v_366.as_canonical_u64(); seed[193] = v_367.as_canonical_u64(); seed[194] = v_368.as_canonical_u64(); seed[195] = v_369.as_canonical_u64(); seed[196] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed[197] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed[198] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[199] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = context.check_returned::<1>(117, 117, &[v_189, v_190, v_354, v_371, v_372, v_373])?; seed[200] = v_374.as_canonical_u64(); Ok(()) }, _ => { let [v_375]: [G; 1] = [G::from_u64(1)]; let [v_376]: [G; 1] = [v_2 + v_375]; let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = context.check_returned::<1>(121, 117, &[v_189, v_190, v_376, v_3, v_377, v_5])?; seed[182] = v_378.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn write_117(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57])]; row[offsets.auxiliaries + 20] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_56.as_canonical_u64(); let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65])]; row[offsets.auxiliaries + 52] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_65.as_canonical_u64(); let [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]: [G; 32] = [G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 60] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = [G::from_u64(seed[98])]; row[offsets.auxiliaries + 92] = v_114.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 20] = (v_24 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_23 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_22 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_21 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_20 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_19 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_18 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_17 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 12] = (v_16 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 13] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39])]; row[offsets.auxiliaries + 24] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = [G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50])]; row[offsets.auxiliaries + 35] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = [G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 46] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 57] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83])]; row[offsets.auxiliaries + 68] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = [G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 79] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_191.as_canonical_u64(); let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104])]; row[offsets.auxiliaries + 90] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = [G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107])]; row[offsets.auxiliaries + 100] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); break 'yield_0 [v_214]; }, _ => { row[offsets.auxiliaries + 103] = (v_211 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_215]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); break 'yield_0 [v_215]; }, } }, _ => { row[offsets.auxiliaries + 100] = (v_201 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_216]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); break 'yield_0 [v_216]; }, } }; row[offsets.auxiliaries + 104] = v_217.as_canonical_u64(); let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; row[offsets.auxiliaries + 105] = g_inverse_value(v_219).as_canonical_u64(); row[offsets.auxiliaries + 106] = v_220.as_canonical_u64(); let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; row[offsets.auxiliaries + 107] = g_inverse_value(v_2).as_canonical_u64(); row[offsets.auxiliaries + 108] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_217 * v_220]; row[offsets.auxiliaries + 109] = v_222.as_canonical_u64(); let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = [G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 110] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [G::from_u64(seed[116])]; row[offsets.auxiliaries + 118] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; row[offsets.auxiliaries + 119] = v_234.as_canonical_u64(); let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = [G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 120] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_255.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_256.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_260.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_261.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_262.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_263.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_264.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_265.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_272.as_canonical_u64(); let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163]), G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166]), G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169]), G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172]), G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175]), G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178]), G::from_u64(seed[179]), G::from_u64(seed[180])]; row[offsets.auxiliaries + 152] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 154] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 157] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_297.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_298.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_299.as_canonical_u64(); row[offsets.auxiliaries + 163] = v_300.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_304.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_305.as_canonical_u64(); row[offsets.auxiliaries + 169] = v_306.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_308.as_canonical_u64(); row[offsets.auxiliaries + 172] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_310.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_312.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_314.as_canonical_u64(); row[offsets.auxiliaries + 178] = v_315.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_316.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_317.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_318.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_322]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 184] = v_322.as_canonical_u64(); row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 184] = (v_217 - G::from_u64(1)).inverse().as_canonical_u64(); match v_220.as_canonical_u64() { 1u64 => { let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = [G::from_u64(seed[181]), G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184]), G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187]), G::from_u64(seed[188])]; row[offsets.auxiliaries + 185] = v_355.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_356.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_357.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_358.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_359.as_canonical_u64(); row[offsets.auxiliaries + 190] = v_360.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_361.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = [G::from_u64(seed[189]), G::from_u64(seed[190]), G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193]), G::from_u64(seed[194]), G::from_u64(seed[195]), G::from_u64(seed[196])]; row[offsets.auxiliaries + 193] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 194] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 195] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 196] = v_366.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_367.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_368.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 200] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = [G::from_u64(seed[197])]; row[offsets.auxiliaries + 201] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = [G::from_u64(seed[198])]; row[offsets.auxiliaries + 202] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = [G::from_u64(seed[199])]; row[offsets.auxiliaries + 203] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = [G::from_u64(seed[200])]; row[offsets.auxiliaries + 204] = v_374.as_canonical_u64(); row[offsets.selectors + 13] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 185] = (v_220 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_377]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 186] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = [G::from_u64(seed[182])]; row[offsets.auxiliaries + 187] = v_378.as_canonical_u64(); row[offsets.selectors + 14] = G::ONE.as_canonical_u64(); }, } }, } }, } } + +static SCHEMA_117: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 312, 316, 8, 320, 324, 16, 404, 405, 406, 407, 408, 409, 410, 411, 328, 332, 412, 24, 32, 40, 48, 56, 64, 72, 80, 336, 340, 413, 414, 415, 416, 417, 418, 419, 420, 421, 344, 348, 422, 423, 424, 425, 426, 427, 428, 429, 430, 352, 356, 431, 432, 433, 434, 435, 436, 437, 438, 439, 360, 364, 440, 441, 442, 443, 444, 445, 446, 447, 448, 368, 372, 449, 450, 451, 452, 453, 454, 455, 456, 457, 376, 380, 458, 459, 460, 461, 462, 463, 464, 465, 466, 384, 388, 467, 468, 88, 96, 104, 112, 120, 128, 136, 144, 152, 469, 160, 168, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 392, 396, 400, 304], bytes: 544 }; + +fn pack_220(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed[6] = v_9.as_canonical_u64(); seed[7] = v_10.as_canonical_u64(); seed[8] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 219, &[v_3, v_10])?; seed[9] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed[10] = v_14.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(220, v_9)) }, } }, _ => { Err(no_match(220, v_2)) }, } } + +fn pack_220_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_2); seed.u32(16, v_3); seed.u32(20, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed.u8(33, v_5); seed.u32(24, v_6); seed.u32(28, v_7); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed.u8(33, v_9); seed.u32(24, v_10); seed.u32(28, v_11); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 219, &[v_3, v_10])?; seed.u8(34, v_12); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed.u8(35, v_14); Ok(()) }, _ => { Err(no_match(220, v_9)) }, } }, _ => { Err(no_match(220, v_2)) }, } } + +fn pack_220_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed[6] = v_9.as_canonical_u64(); seed[7] = v_10.as_canonical_u64(); seed[8] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 219, &[v_3, v_10])?; seed[9] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = context.check_returned::<1>(8, 220, &[v_4, v_11])?; seed[10] = v_14.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(220, v_9)) }, } }, _ => { Err(no_match(220, v_2)) }, } } + +fn write_220(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_14.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(220, v_9)) }, } }, _ => { Err(no_match(220, v_2)) }, } } + +static SCHEMA_220: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 32, 16, 20, 33, 24, 28, 34, 35], bytes: 40 }; + +fn pack_230(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 229, &[v_0, v_8, v_16])?; seed[17] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(2, 229, &[v_1, v_9, v_17])?; seed[18] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(3, 229, &[v_2, v_10, v_18])?; seed[19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(4, 229, &[v_3, v_11, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(5, 229, &[v_4, v_12, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.call::<1>(6, 229, &[v_5, v_13, v_21])?; seed[22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(7, 229, &[v_6, v_14, v_22])?; seed[23] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed[24] = v_24.as_canonical_u64(); Ok(()) } + +fn pack_230_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 229, &[v_0, v_8, v_16])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(2, 229, &[v_1, v_9, v_17])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(3, 229, &[v_2, v_10, v_18])?; seed.full(24, v_19); let [v_20]: [G; 1] = context.call::<1>(4, 229, &[v_3, v_11, v_19])?; seed.full(32, v_20); let [v_21]: [G; 1] = context.call::<1>(5, 229, &[v_4, v_12, v_20])?; seed.full(40, v_21); let [v_22]: [G; 1] = context.call::<1>(6, 229, &[v_5, v_13, v_21])?; seed.full(48, v_22); let [v_23]: [G; 1] = context.call::<1>(7, 229, &[v_6, v_14, v_22])?; seed.full(56, v_23); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed.full(64, v_24); Ok(()) } + +fn pack_230_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 229, &[v_0, v_8, v_16])?; seed[17] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(2, 229, &[v_1, v_9, v_17])?; seed[18] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(3, 229, &[v_2, v_10, v_18])?; seed[19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(4, 229, &[v_3, v_11, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(5, 229, &[v_4, v_12, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.call::<1>(6, 229, &[v_5, v_13, v_21])?; seed[22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(7, 229, &[v_6, v_14, v_22])?; seed[23] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = context.check_returned::<1>(8, 229, &[v_7, v_15, v_23])?; seed[24] = v_24.as_canonical_u64(); Ok(()) } + +fn write_230(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_17]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 3] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 7] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 8] = v_24.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_230: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 8, 16, 24, 32, 40, 48, 56, 64], bytes: 88 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(256)), Op::Mul(9, 66), Op::Add(67, 8), Op::Mul(68, 66), Op::Add(69, 7), Op::Mul(70, 66), Op::Add(71, 6), Op::Mul(72, 66), Op::Add(73, 5), Op::Mul(74, 66), Op::Add(75, 4), Op::Mul(76, 66), Op::Add(77, 3), Op::Mul(41, 66), Op::Add(79, 40), Op::Mul(80, 66), Op::Add(81, 39), Op::Mul(82, 66), Op::Add(83, 38), Op::Mul(84, 66), Op::Add(85, 37), Op::Mul(86, 66), Op::Add(87, 36), Op::Mul(88, 66), Op::Add(89, 35), Op::Sub(78, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 92), Op::Add(93, 15), Op::Mul(94, 92), Op::Add(95, 14), Op::Mul(96, 92), Op::Add(97, 13), Op::Mul(98, 92), Op::Add(99, 12), Op::Mul(100, 92), Op::Add(101, 11), Op::Mul(102, 92), Op::Add(103, 10), Op::Mul(48, 92), Op::Add(105, 47), Op::Mul(106, 92), Op::Add(107, 46), Op::Mul(108, 92), Op::Add(109, 45), Op::Mul(110, 92), Op::Add(111, 44), Op::Mul(112, 92), Op::Add(113, 43), Op::Mul(114, 92), Op::Add(115, 42), Op::Sub(104, 116)], ctrl: Ctrl::Match(117, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(23, 118), Op::Add(119, 22), Op::Mul(120, 118), Op::Add(121, 21), Op::Mul(122, 118), Op::Add(123, 20), Op::Mul(124, 118), Op::Add(125, 19), Op::Mul(126, 118), Op::Add(127, 18), Op::Mul(128, 118), Op::Add(129, 17), Op::Mul(55, 118), Op::Add(131, 54), Op::Mul(132, 118), Op::Add(133, 53), Op::Mul(134, 118), Op::Add(135, 52), Op::Mul(136, 118), Op::Add(137, 51), Op::Mul(138, 118), Op::Add(139, 50), Op::Mul(140, 118), Op::Add(141, 49), Op::Sub(130, 142)], ctrl: Ctrl::Match(143, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(30, 144), Op::Add(145, 29), Op::Mul(146, 144), Op::Add(147, 28), Op::Mul(148, 144), Op::Add(149, 27), Op::Mul(150, 144), Op::Add(151, 26), Op::Mul(152, 144), Op::Add(153, 25), Op::Mul(154, 144), Op::Add(155, 24), Op::Mul(62, 144), Op::Add(157, 61), Op::Mul(158, 144), Op::Add(159, 60), Op::Mul(160, 144), Op::Add(161, 59), Op::Mul(162, 144), Op::Add(163, 58), Op::Mul(164, 144), Op::Add(165, 57), Op::Mul(166, 144), Op::Add(167, 56), Op::Sub(156, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(33, 170), Op::Add(171, 32), Op::Mul(172, 170), Op::Add(173, 31), Op::Mul(65, 170), Op::Add(175, 64), Op::Mul(176, 170), Op::Add(177, 63), Op::Sub(174, 178)], ctrl: Ctrl::Match(179, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![180]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![180]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![170]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![144]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![118]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![92]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 66, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Sub(2, 34)], ctrl: Ctrl::Match(66, [(G::from_u64(0), Block { ops: vec![Op::Call(1, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![67]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![67]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 66, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Sub(2, 3), Op::Call(3, vec![0, 4, 5], 1, false), Op::IORead(0, 1, 1), Op::Const(G::from_u64(0)), Op::Store(vec![8, 7, 6])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Mul(12, 12), Op::AssertEq(vec![13], vec![12], Some("u32_add: carry is not boolean".into()))], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::U8RangeCheck(12, 13), Op::U8RangeCheck(14, 15), Op::Const(G::from_u64(1)), Op::Sub(16, 17), Op::Const(G::from_u64(2)), Op::Sub(16, 19), Op::Mul(18, 20), Op::Mul(16, 21), Op::Const(G::from_u64(0)), Op::AssertEq(vec![22], vec![23], Some("u32_add3: carry is not in {0, 1, 2}".into()))], ctrl: Ctrl::Return(0, vec![12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 4), Op::U8Xor(1, 5), Op::U8Xor(2, 6), Op::U8Xor(3, 7)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 0, 1]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 0]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit7(0, 4), Op::U8XorSplit7(1, 5), Op::U8XorSplit7(2, 6), Op::U8XorSplit7(3, 7), Op::Add(8, 11), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit4(0, 4), Op::U8XorSplit4(1, 5), Op::U8XorSplit4(2, 6), Op::U8XorSplit4(3, 7), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9), Op::Add(8, 11)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 8), Op::Sub(1, 9), Op::Sub(2, 10), Op::Sub(3, 11), Op::Sub(4, 12), Op::Sub(5, 13), Op::Sub(6, 14), Op::Sub(7, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![24]) }))) }, layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(255), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".into())), Op::Const(G::from_u64(256)), Op::Mul(9, 1), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Const(G::from_u64(16777216)), Op::Mul(13, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 6), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(0, 25)], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(8, 1), Op::Const(G::from_u64(65536)), Op::Mul(10, 2), Op::Const(G::from_u64(16777216)), Op::Mul(12, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(14, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(16, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(18, 6), Op::Const(G::from_u64(72057594037927936)), Op::Mul(20, 7), Op::Add(19, 21), Op::Add(17, 22), Op::Add(15, 23), Op::Add(13, 24), Op::Add(11, 25), Op::Add(9, 26), Op::Add(0, 27)], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1020)), Op::Sub(7, 8), Op::Add(6, 9), Op::Add(5, 10), Op::Add(4, 11), Op::EqZero(12), Op::Add(2, 3), Op::Add(1, 14), Op::Add(0, 15), Op::EqZero(16), Op::Const(G::from_u64(1)), Op::Sub(18, 17), Op::Mul(13, 19), Op::Sub(18, 20)], ctrl: Ctrl::Return(0, vec![21]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::Const(G::from_u64(256)), Op::Mul(9, 2), Op::Const(G::from_u64(65536)), Op::Mul(11, 3), Op::Const(G::from_u64(16777216)), Op::Mul(13, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(21, 8), Op::Add(20, 22), Op::Add(18, 23), Op::Add(16, 24), Op::Add(14, 25), Op::Add(12, 26), Op::Add(10, 27), Op::Add(1, 28), Op::AssertEq(vec![29], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(8, 30), Op::Add(7, 31), Op::Add(6, 32), Op::Add(5, 33), Op::EqZero(34), Op::Add(3, 4), Op::Add(2, 36), Op::Add(1, 37), Op::EqZero(38), Op::Const(G::from_u64(1)), Op::Sub(40, 39), Op::Mul(35, 41), Op::Sub(40, 42), Op::AssertEq(vec![43], vec![40], None)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGInverse(0), Op::Mul(0, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 3), Op::Mul(0, 4), Op::Const(G::from_u64(0)), Op::AssertEq(vec![5], vec![6], None), Op::Mul(1, 4), Op::AssertEq(vec![7], vec![6], None)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![Op::Add(0, 2), Op::Add(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::Sub(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(2, 0), Op::Sub(2, 1)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_22() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(5, 6), Op::Add(4, 7), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(9, 10)], ctrl: Ctrl::Return(0, vec![8, 11]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_23() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(3, 4), Op::Sub(2, 5), Op::UnconstrainedGInverse(6), Op::Mul(6, 7), Op::Const(G::from_u64(1)), Op::Sub(8, 9), Op::Mul(6, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], None), Op::Mul(7, 10), Op::AssertEq(vec![13], vec![12], None), Op::Mul(0, 7), Op::Sub(12, 1), Op::Mul(15, 7)], ctrl: Ctrl::Return(0, vec![14, 16]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_24() -> Function { + Function { body: Block { ops: vec![Op::Mul(2, 2), Op::Const(G::from_u64(7)), Op::Mul(3, 3), Op::Mul(5, 6), Op::Sub(4, 7), Op::UnconstrainedGInverse(8), Op::Mul(8, 9), Op::Const(G::from_u64(1)), Op::Sub(10, 11), Op::Mul(8, 12), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], None), Op::Mul(9, 12), Op::AssertEq(vec![15], vec![14], None), Op::Mul(2, 9), Op::Sub(14, 3), Op::Mul(17, 9), Op::Mul(0, 16), Op::Mul(1, 18), Op::Mul(5, 20), Op::Add(19, 21), Op::Mul(0, 18), Op::Mul(1, 16), Op::Add(23, 24)], ctrl: Ctrl::Return(0, vec![22, 25]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 13, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_25() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::EqZero(4), Op::Sub(1, 3), Op::EqZero(6), Op::Mul(5, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_26() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![4, 6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_27() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(26, vec![2], 2, false), Op::Call(26, vec![4], 2, false), Op::Call(26, vec![6], 2, false), Op::Call(26, vec![8], 2, false), Op::Call(26, vec![10], 2, false), Op::Call(26, vec![12], 2, false), Op::Call(26, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_28() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 9, false), Op::Call(14, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_29() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 1), Op::Const(G::from_u64(1)), Op::Add(0, 3)], ctrl: Ctrl::Return(0, vec![2, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_30() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 8), Op::Const(G::from_u64(8)), Op::Add(0, 10)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_31() -> Function { + Function { body: Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(14, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_32() -> Function { + Function { body: Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![9], 9, true), Op::Const(G::from_u64(256)), Op::Mul(19, 2), Op::Const(G::from_u64(65536)), Op::Mul(21, 3), Op::Const(G::from_u64(16777216)), Op::Mul(23, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(25, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(27, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(29, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 8), Op::Add(30, 32), Op::Add(28, 33), Op::Add(26, 34), Op::Add(24, 35), Op::Add(22, 36), Op::Add(20, 37), Op::Add(1, 38), Op::Mul(19, 11), Op::Mul(21, 12), Op::Mul(23, 13), Op::Mul(25, 14), Op::Mul(27, 15), Op::Mul(29, 16), Op::Mul(31, 17), Op::Add(45, 46), Op::Add(44, 47), Op::Add(43, 48), Op::Add(42, 49), Op::Add(41, 50), Op::Add(40, 51), Op::Add(10, 52)], ctrl: Ctrl::Return(0, vec![39, 53, 18]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 19, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_33() -> Function { + Function { body: Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![9], 9, true), Op::Call(30, vec![18], 9, true), Op::Call(30, vec![27], 9, true)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_34() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_35() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, true), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(35, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_36() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(37, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_37() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(37, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_38() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(39, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_39() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![10], 9, true), Op::Const(G::from_u64(256)), Op::Mul(20, 3), Op::Const(G::from_u64(65536)), Op::Mul(22, 4), Op::Const(G::from_u64(16777216)), Op::Mul(24, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(26, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(28, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(30, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(32, 9), Op::Add(31, 33), Op::Add(29, 34), Op::Add(27, 35), Op::Add(25, 36), Op::Add(23, 37), Op::Add(21, 38), Op::Add(2, 39), Op::Mul(20, 12), Op::Mul(22, 13), Op::Mul(24, 14), Op::Mul(26, 15), Op::Mul(28, 16), Op::Mul(30, 17), Op::Mul(32, 18), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(11, 53), Op::Const(G::from_u64(1)), Op::Sub(1, 55), Op::Call(39, vec![19, 56], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![59, 40, 54, 57])], ctrl: Ctrl::Return(1, vec![60, 58]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_40() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(41, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_41() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![10], 9, true), Op::Call(30, vec![19], 9, true), Op::Call(30, vec![28], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(41, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_42() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(43, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_43() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(43, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_44() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(45, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_45() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(43, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(45, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_46() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(47, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_47() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(38, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(47, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_48() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(49, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_49() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(46, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(49, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_50() -> Function { + Function { body: Block { ops: vec![Op::Call(40, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_51() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(52, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_52() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(40, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(52, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_53() -> Function { + Function { body: Block { ops: vec![Op::Call(40, vec![0], 2, false), Op::Call(40, vec![2], 2, false), Op::Call(40, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_54() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(45, vec![2, 1], 2, false), Op::Call(40, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_55() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(56, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_56() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(45, vec![3, 2], 2, false), Op::Call(40, vec![5], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(56, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_57() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, true), Op::Call(31, vec![2], 2, false), Op::Call(47, vec![4, 3], 2, false), Op::Call(40, vec![6], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_58() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(59, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_59() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, true), Op::Call(31, vec![3], 2, false), Op::Call(47, vec![5, 4], 2, false), Op::Call(40, vec![7], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(59, vec![9, 11], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 2, 6, 8, 12])], ctrl: Ctrl::Return(1, vec![15, 13]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_60() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(52, vec![2, 1], 2, false), Op::Call(36, vec![4], 2, false), Op::Call(31, vec![6], 2, false), Op::Call(56, vec![8, 7], 2, false), Op::Call(31, vec![10], 2, false), Op::Call(59, vec![12, 11], 2, false), Op::Call(38, vec![14], 2, false), Op::Call(30, vec![16], 9, true)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 26, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_61() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, true)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(48, vec![2], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_62() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false), Op::Call(40, vec![4], 2, false), Op::Call(40, vec![6], 2, false), Op::Call(40, vec![8], 2, false), Op::Call(38, vec![10], 2, false), Op::Call(31, vec![12], 2, false), Op::Call(35, vec![14, 13], 2, false), Op::Call(31, vec![16], 2, false), Op::Call(52, vec![18, 17], 2, false), Op::Call(36, vec![20], 2, false), Op::Call(31, vec![22], 2, false), Op::Call(56, vec![24, 23], 2, false), Op::Call(31, vec![26], 2, false), Op::Call(59, vec![28, 27], 2, false), Op::Call(38, vec![30], 2, false), Op::Call(30, vec![32], 9, true), Op::Call(48, vec![41], 2, false), Op::Call(61, vec![43], 3, false), Op::Call(48, vec![46], 2, false), Op::Call(48, vec![48], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 7, 9, 11, 15, 19, 21, 25, 29, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 44, 45, 47, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_63() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false), Op::Call(40, vec![4], 2, false), Op::Call(31, vec![6], 2, false), Op::Call(35, vec![8, 7], 2, false), Op::Call(31, vec![10], 2, false), Op::Call(43, vec![12, 11], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 14]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_64() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(65, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_65() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![3, 2], 2, false), Op::Call(40, vec![5], 2, false), Op::Call(31, vec![7], 2, false), Op::Call(35, vec![9, 8], 2, false), Op::Call(31, vec![11], 2, false), Op::Call(43, vec![13, 12], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 16), Op::Call(65, vec![15, 17], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![20, 4, 6, 10, 14, 18])], ctrl: Ctrl::Return(1, vec![21, 19]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_66() -> Function { + Function { body: Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Call(30, vec![2], 9, true)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_67() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(68, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_68() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Call(30, vec![3], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Call(68, vec![12, 14], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![17, 2, 4, 5, 6, 7, 8, 9, 10, 11, 15])], ctrl: Ctrl::Return(1, vec![18, 16]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_69() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(70, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_70() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(62, vec![0], 25, false), Op::Const(G::from_u64(1)), Op::Sub(1, 27), Op::Call(70, vec![26, 28], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![31, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 29])], ctrl: Ctrl::Return(1, vec![32, 30]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_71() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(65, vec![2, 1], 2, false), Op::Call(31, vec![4], 2, false), Op::Call(68, vec![6, 5], 2, false), Op::Call(31, vec![8], 2, false), Op::Call(70, vec![10, 9], 2, false)], ctrl: Ctrl::Return(0, vec![3, 7, 11, 12]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 13, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_72() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(4, 1), Op::Const(G::from_u64(65536)), Op::Mul(6, 2), Op::Const(G::from_u64(16777216)), Op::Mul(8, 3), Op::Add(7, 9), Op::Add(5, 10), Op::Add(0, 11)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_73() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(32, 1), Op::Const(G::from_u64(65536)), Op::Mul(34, 2), Op::Const(G::from_u64(16777216)), Op::Mul(36, 3), Op::Add(35, 37), Op::Add(33, 38), Op::Add(0, 39), Op::Mul(32, 5), Op::Mul(34, 6), Op::Mul(36, 7), Op::Add(42, 43), Op::Add(41, 44), Op::Add(4, 45), Op::Mul(32, 9), Op::Mul(34, 10), Op::Mul(36, 11), Op::Add(48, 49), Op::Add(47, 50), Op::Add(8, 51), Op::Mul(32, 13), Op::Mul(34, 14), Op::Mul(36, 15), Op::Add(54, 55), Op::Add(53, 56), Op::Add(12, 57), Op::Mul(32, 17), Op::Mul(34, 18), Op::Mul(36, 19), Op::Add(60, 61), Op::Add(59, 62), Op::Add(16, 63), Op::Mul(32, 21), Op::Mul(34, 22), Op::Mul(36, 23), Op::Add(66, 67), Op::Add(65, 68), Op::Add(20, 69), Op::Mul(32, 25), Op::Mul(34, 26), Op::Mul(36, 27), Op::Add(72, 73), Op::Add(71, 74), Op::Add(24, 75), Op::Mul(32, 29), Op::Mul(34, 30), Op::Mul(36, 31), Op::Add(78, 79), Op::Add(77, 80), Op::Add(28, 81)], ctrl: Ctrl::Return(0, vec![40, 46, 52, 58, 64, 70, 76, 82]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_74() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(78, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(77, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_75() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(78, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(77, vec![38], 32, false), Op::Store(vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70])], ctrl: Ctrl::Return(0, vec![71]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 39, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_76() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(34, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![68, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(76, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68], 34, false)], ctrl: Ctrl::Match(69, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![103, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 102]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(34, 102)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Mul(104, 33), Op::Add(103, 170), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![172, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 174, 175, 176, 177, 178, 179, 174, 180, 181, 182, 183, 184, 185, 186, 187, 188, 172, 172, 172, 172, 172, 172, 172, 172, 173, 172, 172, 172, 171, 172, 172, 172, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![172, 102, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220])], ctrl: Ctrl::Return(2, vec![172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 221]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![170, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 172, 173, 174, 175, 176, 177, 172, 178, 179, 180, 181, 182, 183, 184, 185, 186, 170, 170, 170, 170, 170, 170, 170, 170, 171, 170, 170, 170, 103, 170, 170, 170, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![170, 102, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218])], ctrl: Ctrl::Return(3, vec![170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 219]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_77() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(34, 2)], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(76, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 69], 34, false)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Call(77, vec![103], 32, false)], ctrl: Ctrl::Return(1, vec![104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![104, 103, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102]), Op::Call(77, vec![105], 32, false)], ctrl: Ctrl::Return(2, vec![106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_78() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![1, 2, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 1])], ctrl: Ctrl::Match(2, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![9, 11, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 12), Op::Add(3, 12), Op::Call(78, vec![9, 11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_79() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 96)], ctrl: Ctrl::Match(97, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 99)], ctrl: Ctrl::Match(100, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 102)], ctrl: Ctrl::Match(103, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 105)], ctrl: Ctrl::Match(106, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 108)], ctrl: Ctrl::Match(109, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 111)], ctrl: Ctrl::Match(112, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 114)], ctrl: Ctrl::Match(115, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 117)], ctrl: Ctrl::Match(118, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 123)], ctrl: Ctrl::Match(124, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 126)], ctrl: Ctrl::Match(127, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 129)], ctrl: Ctrl::Match(130, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 132)], ctrl: Ctrl::Match(133, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 135)], ctrl: Ctrl::Match(136, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 138)], ctrl: Ctrl::Match(139, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 141)], ctrl: Ctrl::Match(142, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 144)], ctrl: Ctrl::Match(145, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 147)], ctrl: Ctrl::Match(148, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 150)], ctrl: Ctrl::Match(151, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 153)], ctrl: Ctrl::Match(154, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 156)], ctrl: Ctrl::Match(157, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 159)], ctrl: Ctrl::Match(160, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 165)], ctrl: Ctrl::Match(166, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 171)], ctrl: Ctrl::Match(172, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 174)], ctrl: Ctrl::Match(175, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 177)], ctrl: Ctrl::Match(178, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 180)], ctrl: Ctrl::Match(181, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 183)], ctrl: Ctrl::Match(184, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 186)], ctrl: Ctrl::Match(187, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 189)], ctrl: Ctrl::Match(190, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 29, 26, 23, 20, 17, 14, 11, 8, 5, 2]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_80() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(80, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_81() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Add(6, 7), Op::Add(8, 17), Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![51, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 60, 61, 62, 63, 64, 65, 60, 66, 67, 68, 69, 70, 71, 72, 73, 74, 52, 53, 54, 55, 56, 57, 58, 59, 51, 51, 51, 51, 18, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51], 32, false), Op::Store(vec![51, 5, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106])], ctrl: Ctrl::Return(0, vec![107]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Load(32, 4), Op::Store(vec![9, 5, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41])], ctrl: Ctrl::Return(9, vec![42]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(8, 3), Op::Call(4, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Sub(2, 1), Op::EqZero(19), Op::Mul(20, 6), Op::Add(18, 21), Op::Add(7, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(80, vec![0, 25], 1, false), Op::Call(79, vec![26], 64, false), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![138, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 123, 129, 130, 131, 132, 133, 134, 135, 136, 137, 9, 10, 11, 12, 13, 14, 15, 16, 1, 138, 138, 138, 23, 138, 138, 138, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90], 32, false), Op::Store(vec![138, 5, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170])], ctrl: Ctrl::Return(10, vec![171]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_82() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(79, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(304, vec![0], 1, false), Op::Load(8, 3), Op::Call(4, vec![74, 75, 76, 77, 78, 79, 80, 81], 1, false), Op::Mul(73, 82), Op::Mul(8, 83), Op::Add(84, 7), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(0)), Op::Call(86, vec![150, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 74, 75, 76, 77, 78, 79, 80, 81, 149, 150, 150, 150, 85, 150, 150, 150, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Store(vec![150, 5, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182]), Op::Const(G::from_u64(1)), Op::Store(vec![184, 184, 184]), Op::Call(13, vec![74, 75, 76, 77, 78, 79, 80, 81], 8, false), Op::Store(vec![186, 187, 188, 189, 190, 191, 192, 193]), Op::Store(vec![86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]), Op::Call(78, vec![0, 185, 150, 150, 194, 195, 183], 1, false)], ctrl: Ctrl::Return(0, vec![196]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(304, vec![0], 1, false), Op::Mul(73, 7), Op::Call(304, vec![0], 1, false), Op::Load(8, 3), Op::Call(4, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(84, 8), Op::Mul(75, 85), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(86, 90), Op::Add(74, 91), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![141, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 126, 127, 128, 129, 130, 131, 126, 132, 133, 134, 135, 136, 137, 138, 139, 140, 76, 77, 78, 79, 80, 81, 82, 83, 125, 141, 141, 141, 92, 141, 141, 141, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Const(G::from_u64(1)), Op::Store(vec![174, 174, 174]), Op::Add(2, 174), Op::Store(vec![142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173]), Op::Call(78, vec![0, 175, 141, 176, 3, 177, 5], 1, false)], ctrl: Ctrl::Return(1, vec![178]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_83() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![16, 17, 18, 19]), Op::U8RangeCheck(24, 25), Op::U8RangeCheck(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Const(G::from_u64(2)), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(28, 33), Op::Const(G::from_u64(0)), Op::AssertEq(vec![34], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(12, 24), Op::U8Xor(13, 25), Op::U8Xor(14, 26), Op::U8Xor(15, 27), Op::UnconstrainedU32Add(vec![8, 9, 10, 11], vec![38, 39, 36, 37]), Op::U8RangeCheck(40, 41), Op::U8RangeCheck(42, 43), Op::Mul(44, 44), Op::AssertEq(vec![45], vec![44], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(4, 40), Op::U8XorSplit4(5, 41), Op::U8XorSplit4(6, 42), Op::U8XorSplit4(7, 43), Op::Add(48, 51), Op::Add(50, 53), Op::Add(52, 47), Op::Add(46, 49), Op::UnconstrainedU32Add3(vec![24, 25, 26, 27], vec![54, 55, 56, 57], vec![20, 21, 22, 23]), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::Sub(62, 29), Op::Sub(62, 31), Op::Mul(63, 64), Op::Mul(62, 65), Op::AssertEq(vec![66], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(38, 58), Op::U8Xor(39, 59), Op::U8Xor(36, 60), Op::U8Xor(37, 61), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![68, 69, 70, 67]), Op::U8RangeCheck(71, 72), Op::U8RangeCheck(73, 74), Op::Mul(75, 75), Op::AssertEq(vec![76], vec![75], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(54, 71), Op::U8XorSplit7(55, 72), Op::U8XorSplit7(56, 73), Op::U8XorSplit7(57, 74), Op::Add(77, 80), Op::Add(79, 82), Op::Add(81, 84), Op::Add(83, 78)], ctrl: Ctrl::Return(0, vec![58, 59, 60, 61, 85, 86, 87, 88, 71, 72, 73, 74, 68, 69, 70, 67]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 47, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_84() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![16, 17, 18, 19], vec![64, 65, 66, 67]), Op::U8RangeCheck(128, 129), Op::U8RangeCheck(130, 131), Op::Const(G::from_u64(1)), Op::Sub(132, 133), Op::Const(G::from_u64(2)), Op::Sub(132, 135), Op::Mul(134, 136), Op::Mul(132, 137), Op::Const(G::from_u64(0)), Op::AssertEq(vec![138], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(48, 128), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::UnconstrainedU32Add(vec![32, 33, 34, 35], vec![142, 143, 140, 141]), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::Mul(148, 148), Op::AssertEq(vec![149], vec![148], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(16, 144), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::Add(152, 155), Op::Add(154, 157), Op::Add(156, 151), Op::Add(150, 153), Op::UnconstrainedU32Add3(vec![128, 129, 130, 131], vec![158, 159, 160, 161], vec![68, 69, 70, 71]), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::Sub(166, 133), Op::Sub(166, 135), Op::Mul(167, 168), Op::Mul(166, 169), Op::AssertEq(vec![170], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(142, 162), Op::U8Xor(143, 163), Op::U8Xor(140, 164), Op::U8Xor(141, 165), Op::UnconstrainedU32Add(vec![144, 145, 146, 147], vec![172, 173, 174, 171]), Op::U8RangeCheck(175, 176), Op::U8RangeCheck(177, 178), Op::Mul(179, 179), Op::AssertEq(vec![180], vec![179], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(158, 175), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::Add(181, 184), Op::Add(183, 186), Op::Add(185, 188), Op::Add(187, 182), Op::UnconstrainedU32Add3(vec![4, 5, 6, 7], vec![20, 21, 22, 23], vec![72, 73, 74, 75]), Op::U8RangeCheck(193, 194), Op::U8RangeCheck(195, 196), Op::Sub(197, 133), Op::Sub(197, 135), Op::Mul(198, 199), Op::Mul(197, 200), Op::AssertEq(vec![201], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(52, 193), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::UnconstrainedU32Add(vec![36, 37, 38, 39], vec![204, 205, 202, 203]), Op::U8RangeCheck(206, 207), Op::U8RangeCheck(208, 209), Op::Mul(210, 210), Op::AssertEq(vec![211], vec![210], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(20, 206), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::Add(214, 217), Op::Add(216, 219), Op::Add(218, 213), Op::Add(212, 215), Op::UnconstrainedU32Add3(vec![193, 194, 195, 196], vec![220, 221, 222, 223], vec![76, 77, 78, 79]), Op::U8RangeCheck(224, 225), Op::U8RangeCheck(226, 227), Op::Sub(228, 133), Op::Sub(228, 135), Op::Mul(229, 230), Op::Mul(228, 231), Op::AssertEq(vec![232], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(204, 224), Op::U8Xor(205, 225), Op::U8Xor(202, 226), Op::U8Xor(203, 227), Op::UnconstrainedU32Add(vec![206, 207, 208, 209], vec![234, 235, 236, 233]), Op::U8RangeCheck(237, 238), Op::U8RangeCheck(239, 240), Op::Mul(241, 241), Op::AssertEq(vec![242], vec![241], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(220, 237), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::Add(243, 246), Op::Add(245, 248), Op::Add(247, 250), Op::Add(249, 244), Op::UnconstrainedU32Add3(vec![8, 9, 10, 11], vec![24, 25, 26, 27], vec![80, 81, 82, 83]), Op::U8RangeCheck(255, 256), Op::U8RangeCheck(257, 258), Op::Sub(259, 133), Op::Sub(259, 135), Op::Mul(260, 261), Op::Mul(259, 262), Op::AssertEq(vec![263], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(56, 255), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![266, 267, 264, 265]), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::Mul(272, 272), Op::AssertEq(vec![273], vec![272], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(24, 268), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::Add(276, 279), Op::Add(278, 281), Op::Add(280, 275), Op::Add(274, 277), Op::UnconstrainedU32Add3(vec![255, 256, 257, 258], vec![282, 283, 284, 285], vec![84, 85, 86, 87]), Op::U8RangeCheck(286, 287), Op::U8RangeCheck(288, 289), Op::Sub(290, 133), Op::Sub(290, 135), Op::Mul(291, 292), Op::Mul(290, 293), Op::AssertEq(vec![294], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(266, 286), Op::U8Xor(267, 287), Op::U8Xor(264, 288), Op::U8Xor(265, 289), Op::UnconstrainedU32Add(vec![268, 269, 270, 271], vec![296, 297, 298, 295]), Op::U8RangeCheck(299, 300), Op::U8RangeCheck(301, 302), Op::Mul(303, 303), Op::AssertEq(vec![304], vec![303], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(282, 299), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::Add(305, 308), Op::Add(307, 310), Op::Add(309, 312), Op::Add(311, 306), Op::UnconstrainedU32Add3(vec![12, 13, 14, 15], vec![28, 29, 30, 31], vec![88, 89, 90, 91]), Op::U8RangeCheck(317, 318), Op::U8RangeCheck(319, 320), Op::Sub(321, 133), Op::Sub(321, 135), Op::Mul(322, 323), Op::Mul(321, 324), Op::AssertEq(vec![325], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(60, 317), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::UnconstrainedU32Add(vec![44, 45, 46, 47], vec![328, 329, 326, 327]), Op::U8RangeCheck(330, 331), Op::U8RangeCheck(332, 333), Op::Mul(334, 334), Op::AssertEq(vec![335], vec![334], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(28, 330), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::Add(338, 341), Op::Add(340, 343), Op::Add(342, 337), Op::Add(336, 339), Op::UnconstrainedU32Add3(vec![317, 318, 319, 320], vec![344, 345, 346, 347], vec![92, 93, 94, 95]), Op::U8RangeCheck(348, 349), Op::U8RangeCheck(350, 351), Op::Sub(352, 133), Op::Sub(352, 135), Op::Mul(353, 354), Op::Mul(352, 355), Op::AssertEq(vec![356], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(328, 348), Op::U8Xor(329, 349), Op::U8Xor(326, 350), Op::U8Xor(327, 351), Op::UnconstrainedU32Add(vec![330, 331, 332, 333], vec![358, 359, 360, 357]), Op::U8RangeCheck(361, 362), Op::U8RangeCheck(363, 364), Op::Mul(365, 365), Op::AssertEq(vec![366], vec![365], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(344, 361), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::Add(367, 370), Op::Add(369, 372), Op::Add(371, 374), Op::Add(373, 368), Op::UnconstrainedU32Add3(vec![162, 163, 164, 165], vec![251, 252, 253, 254], vec![96, 97, 98, 99]), Op::U8RangeCheck(379, 380), Op::U8RangeCheck(381, 382), Op::Sub(383, 133), Op::Sub(383, 135), Op::Mul(384, 385), Op::Mul(383, 386), Op::AssertEq(vec![387], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(358, 379), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(357, 382), Op::UnconstrainedU32Add(vec![299, 300, 301, 302], vec![390, 391, 388, 389]), Op::U8RangeCheck(392, 393), Op::U8RangeCheck(394, 395), Op::Mul(396, 396), Op::AssertEq(vec![397], vec![396], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(251, 392), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::Add(400, 403), Op::Add(402, 405), Op::Add(404, 399), Op::Add(398, 401), Op::UnconstrainedU32Add3(vec![379, 380, 381, 382], vec![406, 407, 408, 409], vec![100, 101, 102, 103]), Op::U8RangeCheck(410, 411), Op::U8RangeCheck(412, 413), Op::Sub(414, 133), Op::Sub(414, 135), Op::Mul(415, 416), Op::Mul(414, 417), Op::AssertEq(vec![418], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(390, 410), Op::U8Xor(391, 411), Op::U8Xor(388, 412), Op::U8Xor(389, 413), Op::UnconstrainedU32Add(vec![392, 393, 394, 395], vec![420, 421, 422, 419]), Op::U8RangeCheck(423, 424), Op::U8RangeCheck(425, 426), Op::Mul(427, 427), Op::AssertEq(vec![428], vec![427], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(406, 423), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::Add(429, 432), Op::Add(431, 434), Op::Add(433, 436), Op::Add(435, 430), Op::UnconstrainedU32Add3(vec![224, 225, 226, 227], vec![313, 314, 315, 316], vec![104, 105, 106, 107]), Op::U8RangeCheck(441, 442), Op::U8RangeCheck(443, 444), Op::Sub(445, 133), Op::Sub(445, 135), Op::Mul(446, 447), Op::Mul(445, 448), Op::AssertEq(vec![449], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(172, 441), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(171, 444), Op::UnconstrainedU32Add(vec![361, 362, 363, 364], vec![452, 453, 450, 451]), Op::U8RangeCheck(454, 455), Op::U8RangeCheck(456, 457), Op::Mul(458, 458), Op::AssertEq(vec![459], vec![458], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(313, 454), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::Add(462, 465), Op::Add(464, 467), Op::Add(466, 461), Op::Add(460, 463), Op::UnconstrainedU32Add3(vec![441, 442, 443, 444], vec![468, 469, 470, 471], vec![108, 109, 110, 111]), Op::U8RangeCheck(472, 473), Op::U8RangeCheck(474, 475), Op::Sub(476, 133), Op::Sub(476, 135), Op::Mul(477, 478), Op::Mul(476, 479), Op::AssertEq(vec![480], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(452, 472), Op::U8Xor(453, 473), Op::U8Xor(450, 474), Op::U8Xor(451, 475), Op::UnconstrainedU32Add(vec![454, 455, 456, 457], vec![482, 483, 484, 481]), Op::U8RangeCheck(485, 486), Op::U8RangeCheck(487, 488), Op::Mul(489, 489), Op::AssertEq(vec![490], vec![489], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(468, 485), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::Add(491, 494), Op::Add(493, 496), Op::Add(495, 498), Op::Add(497, 492), Op::UnconstrainedU32Add3(vec![286, 287, 288, 289], vec![375, 376, 377, 378], vec![112, 113, 114, 115]), Op::U8RangeCheck(503, 504), Op::U8RangeCheck(505, 506), Op::Sub(507, 133), Op::Sub(507, 135), Op::Mul(508, 509), Op::Mul(507, 510), Op::AssertEq(vec![511], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(234, 503), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(233, 506), Op::UnconstrainedU32Add(vec![175, 176, 177, 178], vec![514, 515, 512, 513]), Op::U8RangeCheck(516, 517), Op::U8RangeCheck(518, 519), Op::Mul(520, 520), Op::AssertEq(vec![521], vec![520], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(375, 516), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::Add(524, 527), Op::Add(526, 529), Op::Add(528, 523), Op::Add(522, 525), Op::UnconstrainedU32Add3(vec![503, 504, 505, 506], vec![530, 531, 532, 533], vec![116, 117, 118, 119]), Op::U8RangeCheck(534, 535), Op::U8RangeCheck(536, 537), Op::Sub(538, 133), Op::Sub(538, 135), Op::Mul(539, 540), Op::Mul(538, 541), Op::AssertEq(vec![542], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(514, 534), Op::U8Xor(515, 535), Op::U8Xor(512, 536), Op::U8Xor(513, 537), Op::UnconstrainedU32Add(vec![516, 517, 518, 519], vec![544, 545, 546, 543]), Op::U8RangeCheck(547, 548), Op::U8RangeCheck(549, 550), Op::Mul(551, 551), Op::AssertEq(vec![552], vec![551], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(530, 547), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::Add(553, 556), Op::Add(555, 558), Op::Add(557, 560), Op::Add(559, 554), Op::UnconstrainedU32Add3(vec![348, 349, 350, 351], vec![189, 190, 191, 192], vec![120, 121, 122, 123]), Op::U8RangeCheck(565, 566), Op::U8RangeCheck(567, 568), Op::Sub(569, 133), Op::Sub(569, 135), Op::Mul(570, 571), Op::Mul(569, 572), Op::AssertEq(vec![573], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(296, 565), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(295, 568), Op::UnconstrainedU32Add(vec![237, 238, 239, 240], vec![576, 577, 574, 575]), Op::U8RangeCheck(578, 579), Op::U8RangeCheck(580, 581), Op::Mul(582, 582), Op::AssertEq(vec![583], vec![582], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(189, 578), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::Add(586, 589), Op::Add(588, 591), Op::Add(590, 585), Op::Add(584, 587), Op::UnconstrainedU32Add3(vec![565, 566, 567, 568], vec![592, 593, 594, 595], vec![124, 125, 126, 127]), Op::U8RangeCheck(596, 597), Op::U8RangeCheck(598, 599), Op::Sub(600, 133), Op::Sub(600, 135), Op::Mul(601, 602), Op::Mul(600, 603), Op::AssertEq(vec![604], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(576, 596), Op::U8Xor(577, 597), Op::U8Xor(574, 598), Op::U8Xor(575, 599), Op::UnconstrainedU32Add(vec![578, 579, 580, 581], vec![606, 607, 608, 605]), Op::U8RangeCheck(609, 610), Op::U8RangeCheck(611, 612), Op::Mul(613, 613), Op::AssertEq(vec![614], vec![613], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(592, 609), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::Add(615, 618), Op::Add(617, 620), Op::Add(619, 622), Op::Add(621, 616)], ctrl: Ctrl::Return(0, vec![410, 411, 412, 413, 472, 473, 474, 475, 534, 535, 536, 537, 596, 597, 598, 599, 623, 624, 625, 626, 437, 438, 439, 440, 499, 500, 501, 502, 561, 562, 563, 564, 547, 548, 549, 550, 609, 610, 611, 612, 423, 424, 425, 426, 485, 486, 487, 488, 482, 483, 484, 481, 544, 545, 546, 543, 606, 607, 608, 605, 420, 421, 422, 419, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]) }, layout: FunctionLayout { input_size: 128, selectors: 1, auxiliaries: 369, lookups: 193 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_85() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![121, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 106, 107, 108, 109, 110, 111, 106, 112, 113, 114, 115, 116, 117, 118, 119, 120, 96, 97, 98, 99, 100, 101, 102, 103, 104, 121, 121, 121, 105, 121, 121, 121, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], 32, false)], ctrl: Ctrl::Return(0, vec![122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153]) }, layout: FunctionLayout { input_size: 106, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_86() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(86, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_87() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_88() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_89() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6)], ctrl: Ctrl::Return(0, vec![7, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_90() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7, 1, 3, 8, 8, 8, 8, 8, 8, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_91() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Call(87, vec![4], 2, false), Op::Call(87, vec![6], 2, false), Op::Const(G::from_u64(256)), Op::Mul(9, 3), Op::Const(G::from_u64(65536)), Op::Mul(11, 5), Op::Const(G::from_u64(16777216)), Op::Mul(13, 7), Op::Add(12, 14), Op::Add(10, 15), Op::Add(1, 16), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17, 1, 3, 5, 7, 18, 18, 18, 18, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_92() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Call(87, vec![4], 2, false), Op::Call(87, vec![6], 2, false), Op::Call(87, vec![8], 2, false), Op::Call(87, vec![10], 2, false), Op::Call(87, vec![12], 2, false), Op::Call(87, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_93() -> Function { + Function { body: Block { ops: vec![Op::Call(92, vec![0], 9, false), Op::Const(G::from_u64(256)), Op::Mul(10, 2), Op::Const(G::from_u64(65536)), Op::Mul(12, 3), Op::Const(G::from_u64(16777216)), Op::Mul(14, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 8), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(1, 29)], ctrl: Ctrl::Return(0, vec![30, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 10, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_94() -> Function { + Function { body: Block { ops: vec![Op::Call(92, vec![0], 9, false), Op::Call(92, vec![9], 9, false), Op::Call(92, vec![18], 9, false), Op::Call(92, vec![27], 9, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_95() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(92, vec![0], 9, false), Op::Call(92, vec![10], 9, false), Op::Call(92, vec![19], 9, false), Op::Call(92, vec![28], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(95, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_96() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3, 3, 3, 3])], ctrl: Ctrl::Return(0, vec![4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(88, vec![0], 2, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(93, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(2, vec![13, 11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(88, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 13, 5, 12, 12, 10])], ctrl: Ctrl::Return(3, vec![14, 11]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(96, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(4, vec![12, 9]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(96, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(5, vec![12, 9]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(96, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(5)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(6, vec![12, 9]) }), (G::from_u64(6), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(89, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(96, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(6)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(7, vec![18, 15]) }), (G::from_u64(7), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(89, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(96, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(7)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(8, vec![18, 15]) }), (G::from_u64(8), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(89, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(96, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(9, vec![18, 15]) }), (G::from_u64(9), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 8), Op::Add(2, 8), Op::Call(96, vec![6, 9, 10], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(9)), Op::Store(vec![13, 14, 5, 13, 13, 11])], ctrl: Ctrl::Return(10, vec![15, 12]) }), (G::from_u64(10), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 12, 5, 10])], ctrl: Ctrl::Return(11, vec![13, 11]) }), (G::from_u64(11), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 7, 5, 10])], ctrl: Ctrl::Return(12, vec![13, 11]) }), (G::from_u64(12), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 12, 5, 10])], ctrl: Ctrl::Return(13, vec![13, 11]) }), (G::from_u64(13), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 7, 5, 10])], ctrl: Ctrl::Return(14, vec![13, 11]) }), (G::from_u64(14), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 12, 5, 10])], ctrl: Ctrl::Return(15, vec![14, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 7, 5, 10])], ctrl: Ctrl::Return(16, vec![14, 11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_97() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(97, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_98() -> Function { + Function { body: Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Call(89, vec![2], 2, false), Op::Call(97, vec![4, 3], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_99() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Call(89, vec![3], 2, false), Op::Call(97, vec![5, 4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(99, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 2, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_100() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(2, 3), Op::Call(100, vec![4, 5, 2], 1, false), Op::Add(3, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(1, 3), Op::Call(100, vec![4, 5, 2], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_101() -> Function { + Function { body: Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![10], 10, false), Op::Call(91, vec![20], 10, false), Op::Call(90, vec![30], 10, false), Op::Call(88, vec![40], 2, false), Op::Call(89, vec![42], 2, false), Op::Const(G::from_u64(0)), Op::Call(96, vec![44, 43, 45], 2, false), Op::Call(89, vec![47], 2, false), Op::Call(97, vec![49, 48], 2, false), Op::Call(89, vec![51], 2, false), Op::Call(99, vec![53, 52], 2, false), Op::Call(100, vec![52, 45, 41], 1, false), Op::EqZero(56), Op::Add(56, 57), Op::Add(58, 58), Op::Add(48, 59), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(61, 62), Op::U8RangeCheck(63, 64), Op::U8RangeCheck(65, 66), Op::U8RangeCheck(67, 68), Op::Const(G::from_u64(256)), Op::Mul(69, 62), Op::Const(G::from_u64(65536)), Op::Mul(71, 63), Op::Const(G::from_u64(16777216)), Op::Mul(73, 64), Op::Const(G::from_u64(4294967296)), Op::Mul(75, 65), Op::Const(G::from_u64(1099511627776)), Op::Mul(77, 66), Op::Const(G::from_u64(281474976710656)), Op::Mul(79, 67), Op::Const(G::from_u64(72057594037927936)), Op::Mul(81, 68), Op::Add(80, 82), Op::Add(78, 83), Op::Add(76, 84), Op::Add(74, 85), Op::Add(72, 86), Op::Add(70, 87), Op::Add(61, 88), Op::AssertEq(vec![89], vec![60], None), Op::Const(G::from_u64(1020)), Op::Sub(68, 90), Op::Add(67, 91), Op::Add(66, 92), Op::Add(65, 93), Op::EqZero(94), Op::Add(63, 64), Op::Add(62, 96), Op::Add(61, 97), Op::EqZero(98), Op::Const(G::from_u64(1)), Op::Sub(100, 99), Op::Mul(95, 101), Op::Sub(100, 102), Op::AssertEq(vec![103], vec![100], None), Op::UnconstrainedGToBytes(59), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 107), Op::U8RangeCheck(108, 109), Op::U8RangeCheck(110, 111), Op::Mul(69, 105), Op::Mul(71, 106), Op::Mul(73, 107), Op::Mul(75, 108), Op::Mul(77, 109), Op::Mul(79, 110), Op::Mul(81, 111), Op::Add(117, 118), Op::Add(116, 119), Op::Add(115, 120), Op::Add(114, 121), Op::Add(113, 122), Op::Add(112, 123), Op::Add(104, 124), Op::AssertEq(vec![125], vec![59], None), Op::Sub(111, 90), Op::Add(110, 126), Op::Add(109, 127), Op::Add(108, 128), Op::EqZero(129), Op::Add(106, 107), Op::Add(105, 131), Op::Add(104, 132), Op::EqZero(133), Op::Sub(100, 134), Op::Mul(130, 135), Op::Sub(100, 136), Op::AssertEq(vec![137], vec![100], None), Op::UnconstrainedGToBytes(41), Op::U8RangeCheck(138, 139), Op::U8RangeCheck(140, 141), Op::U8RangeCheck(142, 143), Op::U8RangeCheck(144, 145), Op::Mul(69, 139), Op::Mul(71, 140), Op::Mul(73, 141), Op::Mul(75, 142), Op::Mul(77, 143), Op::Mul(79, 144), Op::Mul(81, 145), Op::Add(151, 152), Op::Add(150, 153), Op::Add(149, 154), Op::Add(148, 155), Op::Add(147, 156), Op::Add(146, 157), Op::Add(138, 158), Op::AssertEq(vec![159], vec![41], None), Op::Sub(145, 90), Op::Add(144, 160), Op::Add(143, 161), Op::Add(142, 162), Op::EqZero(163), Op::Add(140, 141), Op::Add(139, 165), Op::Add(138, 166), Op::EqZero(167), Op::Sub(100, 168), Op::Mul(164, 169), Op::Sub(100, 170), Op::AssertEq(vec![171], vec![100], None)], ctrl: Ctrl::Return(0, vec![46, 43, 50, 31, 54, 41, 1, 11, 59, 61, 62, 63, 64, 65, 66, 67, 68, 32, 33, 34, 35, 36, 37, 38, 39, 22, 23, 24, 25, 26, 27, 28, 29, 12, 13, 14, 15, 16, 17, 18, 19, 2, 3, 4, 5, 6, 7, 8, 9, 104, 105, 106, 107, 108, 109, 110, 111, 138, 139, 140, 141, 142, 143, 144, 145, 55]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 97, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_102() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![57, 48, 49, 50, 51, 52, 53, 54, 55, 56]), Op::Store(vec![57, 40, 41, 42, 43, 44, 45, 46, 47, 58]), Op::Store(vec![57, 32, 33, 34, 35, 36, 37, 38, 39, 59]), Op::Store(vec![57, 24, 25, 26, 27, 28, 29, 30, 31, 60]), Op::Store(vec![57, 16, 17, 18, 19, 20, 21, 22, 23, 61]), Op::Store(vec![57, 8, 9, 10, 11, 12, 13, 14, 15, 62]), Op::Store(vec![57, 0, 1, 2, 3, 4, 5, 6, 7, 63])], ctrl: Ctrl::Return(0, vec![64]) }, layout: FunctionLayout { input_size: 57, selectors: 1, auxiliaries: 8, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_103() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![11], 10, false), Op::Call(91, vec![21], 10, false), Op::Call(90, vec![31], 10, false), Op::Call(88, vec![41], 2, false), Op::Call(89, vec![43], 2, false), Op::Const(G::from_u64(0)), Op::Call(96, vec![45, 44, 46], 2, false), Op::Call(89, vec![48], 2, false), Op::Call(97, vec![50, 49], 2, false), Op::Call(89, vec![52], 2, false), Op::Call(99, vec![54, 53], 2, false), Op::Call(100, vec![53, 46, 42], 1, false), Op::EqZero(57), Op::Add(57, 58), Op::Add(59, 59), Op::Add(49, 60), Op::UnconstrainedGToBytes(61), Op::U8RangeCheck(62, 63), Op::U8RangeCheck(64, 65), Op::U8RangeCheck(66, 67), Op::U8RangeCheck(68, 69), Op::Const(G::from_u64(256)), Op::Mul(70, 63), Op::Const(G::from_u64(65536)), Op::Mul(72, 64), Op::Const(G::from_u64(16777216)), Op::Mul(74, 65), Op::Const(G::from_u64(4294967296)), Op::Mul(76, 66), Op::Const(G::from_u64(1099511627776)), Op::Mul(78, 67), Op::Const(G::from_u64(281474976710656)), Op::Mul(80, 68), Op::Const(G::from_u64(72057594037927936)), Op::Mul(82, 69), Op::Add(81, 83), Op::Add(79, 84), Op::Add(77, 85), Op::Add(75, 86), Op::Add(73, 87), Op::Add(71, 88), Op::Add(62, 89), Op::AssertEq(vec![90], vec![61], None), Op::Const(G::from_u64(1020)), Op::Sub(69, 91), Op::Add(68, 92), Op::Add(67, 93), Op::Add(66, 94), Op::EqZero(95), Op::Add(64, 65), Op::Add(63, 97), Op::Add(62, 98), Op::EqZero(99), Op::Const(G::from_u64(1)), Op::Sub(101, 100), Op::Mul(96, 102), Op::Sub(101, 103), Op::AssertEq(vec![104], vec![101], None), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(105, 106), Op::U8RangeCheck(107, 108), Op::U8RangeCheck(109, 110), Op::U8RangeCheck(111, 112), Op::Mul(70, 106), Op::Mul(72, 107), Op::Mul(74, 108), Op::Mul(76, 109), Op::Mul(78, 110), Op::Mul(80, 111), Op::Mul(82, 112), Op::Add(118, 119), Op::Add(117, 120), Op::Add(116, 121), Op::Add(115, 122), Op::Add(114, 123), Op::Add(113, 124), Op::Add(105, 125), Op::AssertEq(vec![126], vec![60], None), Op::Sub(112, 91), Op::Add(111, 127), Op::Add(110, 128), Op::Add(109, 129), Op::EqZero(130), Op::Add(107, 108), Op::Add(106, 132), Op::Add(105, 133), Op::EqZero(134), Op::Sub(101, 135), Op::Mul(131, 136), Op::Sub(101, 137), Op::AssertEq(vec![138], vec![101], None), Op::UnconstrainedGToBytes(42), Op::U8RangeCheck(139, 140), Op::U8RangeCheck(141, 142), Op::U8RangeCheck(143, 144), Op::U8RangeCheck(145, 146), Op::Mul(70, 140), Op::Mul(72, 141), Op::Mul(74, 142), Op::Mul(76, 143), Op::Mul(78, 144), Op::Mul(80, 145), Op::Mul(82, 146), Op::Add(152, 153), Op::Add(151, 154), Op::Add(150, 155), Op::Add(149, 156), Op::Add(148, 157), Op::Add(147, 158), Op::Add(139, 159), Op::AssertEq(vec![160], vec![42], None), Op::Sub(146, 91), Op::Add(145, 161), Op::Add(144, 162), Op::Add(143, 163), Op::EqZero(164), Op::Add(141, 142), Op::Add(140, 166), Op::Add(139, 167), Op::EqZero(168), Op::Sub(101, 169), Op::Mul(165, 170), Op::Sub(101, 171), Op::AssertEq(vec![172], vec![101], None), Op::Sub(1, 101), Op::Call(103, vec![56, 173], 3, false), Op::Store(vec![46, 47, 44, 51, 32, 55, 42, 2, 12, 60, 174]), Op::Store(vec![46, 139, 140, 141, 142, 143, 144, 145, 146, 175]), Op::Store(vec![46, 105, 106, 107, 108, 109, 110, 111, 112, 178]), Op::Store(vec![46, 3, 4, 5, 6, 7, 8, 9, 10, 179]), Op::Store(vec![46, 13, 14, 15, 16, 17, 18, 19, 20, 180]), Op::Store(vec![46, 23, 24, 25, 26, 27, 28, 29, 30, 181]), Op::Store(vec![46, 33, 34, 35, 36, 37, 38, 39, 40, 182]), Op::Store(vec![46, 62, 63, 64, 65, 66, 67, 68, 69, 183])], ctrl: Ctrl::Return(1, vec![177, 184, 176]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 109, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_104() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![2], 2, false), Op::Call(95, vec![4, 3], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7, 5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_105() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(105, vec![3, 5], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(65535), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 9, 2, 6])], ctrl: Ctrl::Return(2, vec![10, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_106() -> Function { + Function { body: Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![10], 10, false), Op::Call(90, vec![20], 10, false), Op::Call(90, vec![30], 10, false), Op::Call(90, vec![40], 10, false), Op::Call(90, vec![50], 10, false), Op::Call(90, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79])], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 80, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 79, lookups: 16 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_107() -> Function { + Function { body: Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![10], 10, false), Op::Call(90, vec![20], 10, false), Op::Call(90, vec![30], 10, false), Op::Call(90, vec![40], 10, false), Op::Call(90, vec![50], 10, false), Op::Call(90, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79]), Op::Call(90, vec![70], 10, false), Op::Call(103, vec![90, 81], 3, false), Op::Call(104, vec![93], 3, false), Op::Call(105, vec![96, 81], 2, false), Op::Store(vec![71, 82, 83, 84, 85, 86, 87, 88, 89, 92]), Op::Call(306, vec![80, 99], 1, false)], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 100, 91, 94, 95, 97, 98]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 99, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_108() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 4]), Op::Store(vec![5, 2, 6]), Op::Store(vec![5, 1, 7]), Op::Store(vec![5, 0, 8])], ctrl: Ctrl::Return(0, vec![9]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_109() -> Function { + Function { body: Block { ops: vec![Op::Call(108, vec![28, 29, 30, 31, 32], 1, false), Op::Call(108, vec![24, 25, 26, 27, 33], 1, false), Op::Call(108, vec![20, 21, 22, 23, 34], 1, false), Op::Call(108, vec![16, 17, 18, 19, 35], 1, false), Op::Call(108, vec![12, 13, 14, 15, 36], 1, false), Op::Call(108, vec![8, 9, 10, 11, 37], 1, false), Op::Call(108, vec![4, 5, 6, 7, 38], 1, false), Op::Call(108, vec![0, 1, 2, 3, 39], 1, false)], ctrl: Ctrl::Return(0, vec![40]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_110() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_111() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(11)), Op::Call(86, vec![97, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 97, 97, 97, 97, 97, 97, 97, 97, 98, 97, 97, 97, 99, 97, 97, 97, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96], 32, false), Op::Store(vec![100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131])], ctrl: Ctrl::Return(0, vec![132]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 98, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_112() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(111, vec![1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(111, vec![2, 1], 1, false)], ctrl: Ctrl::Return(1, vec![3]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_113() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1), Op::EqZero(5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(113, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_114() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Sub(7, 2), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(114, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(114, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(114, vec![5, 8, 2], 1, false), Op::Store(vec![21, 4, 22])], ctrl: Ctrl::Return(3, vec![23]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_115() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(2, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(115, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(115, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(115, vec![5, 8, 2], 1, false), Op::Store(vec![20, 4, 21])], ctrl: Ctrl::Return(3, vec![22]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 27, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_116() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(12, 4), Op::Const(G::from_u64(65536)), Op::Mul(14, 5), Op::Const(G::from_u64(16777216)), Op::Mul(16, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 10), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(3, 31), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(33, 34), Op::U8RangeCheck(35, 36), Op::U8RangeCheck(37, 38), Op::U8RangeCheck(39, 40), Op::Mul(12, 34), Op::Mul(14, 35), Op::Mul(16, 36), Op::Mul(18, 37), Op::Mul(20, 38), Op::Mul(22, 39), Op::Mul(24, 40), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(33, 53), Op::AssertEq(vec![54], vec![32], None), Op::Const(G::from_u64(1020)), Op::Sub(40, 55), Op::Add(39, 56), Op::Add(38, 57), Op::Add(37, 58), Op::EqZero(59), Op::Add(35, 36), Op::Add(34, 61), Op::Add(33, 62), Op::EqZero(63), Op::Const(G::from_u64(1)), Op::Sub(65, 64), Op::Mul(60, 66), Op::Sub(65, 67), Op::AssertEq(vec![68], vec![65], None)], ctrl: Ctrl::Return(0, vec![33, 34, 35, 36, 37, 38, 39, 40, 11, 1, 65]) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![15, 15, 15, 15, 15, 15, 15, 15, 0, 1, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(116, vec![13, 14], 11, false)], ctrl: Ctrl::Return(2, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_117() -> Function { + Function { body: Block { ops: vec![Op::Call(116, vec![0, 1], 11, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(24, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![57, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, 70, 71, 72, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 58, 59, 60, 61, 62, 63, 64, 65, 57, 57, 57, 57, 66, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57], 32, false), Op::Store(vec![57, 5, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113])], ctrl: Ctrl::Return(0, vec![114]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(116, vec![14, 15], 11, false), Op::Call(116, vec![25, 26], 11, false), Op::Call(116, vec![36, 37], 11, false), Op::Call(116, vec![47, 48], 11, false), Op::Call(116, vec![58, 59], 11, false), Op::Call(116, vec![69, 70], 11, false), Op::Call(116, vec![80, 81], 11, false), Op::Const(G::from_u64(8)), Op::Add(82, 93), Op::Add(71, 95), Op::Add(60, 96), Op::Add(49, 97), Op::Add(38, 98), Op::Add(27, 99), Op::Add(16, 100), Op::Mul(94, 101), Op::Load(10, 91)], ctrl: Ctrl::MatchContinue(103, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(9, vec![116]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![116]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(11, vec![113]) })), 1, 4, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(15)), Op::Sub(2, 114), Op::EqZero(115), Op::EqZero(2), Op::Mul(113, 116), Op::Sub(116, 118), Op::Add(113, 119), Op::Load(8, 3), Op::Call(4, vec![121, 122, 123, 124, 125, 126, 127, 128], 1, false), Op::Mul(113, 129), Op::Const(G::from_u64(2)), Op::Mul(131, 120), Op::Const(G::from_u64(8)), Op::Mul(133, 130), Op::Add(132, 134), Op::Add(117, 135), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![184, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 169, 175, 176, 177, 178, 179, 180, 181, 182, 183, 121, 122, 123, 124, 125, 126, 127, 128, 102, 184, 184, 184, 136, 184, 184, 184, 6, 7, 8, 9, 10, 11, 12, 13, 17, 18, 19, 20, 21, 22, 23, 24, 28, 29, 30, 31, 32, 33, 34, 35, 39, 40, 41, 42, 43, 44, 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 61, 62, 63, 64, 65, 66, 67, 68, 72, 73, 74, 75, 76, 77, 78, 79, 83, 84, 85, 86, 87, 88, 89, 90], 32, false)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![217, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216])], ctrl: Ctrl::Return(12, vec![218]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(116, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Call(13, vec![249, 250, 251, 252, 253, 254, 255, 256], 8, false), Op::Store(vec![257, 258, 259, 260, 261, 262, 263, 264]), Op::Store(vec![217, 218, 219, 220, 221, 222, 217, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247]), Op::Store(vec![248, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(117, vec![91, 92, 248, 265, 266, 267], 1, false)], ctrl: Ctrl::Return(13, vec![268]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 217), Op::Store(vec![185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(117, vec![91, 92, 218, 3, 219, 5], 1, false)], ctrl: Ctrl::Return(14, vec![220]) }))) }))) })) }))) }, layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_118() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(117, vec![33, 0, 34, 35, 36, 37], 1, false), Op::Call(77, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_119() -> Function { + Function { body: Block { ops: vec![Op::Call(114, vec![0, 1, 2], 1, false), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Const(G::from_u64(0)), Op::Store(vec![37, 37, 37, 37, 37, 37, 37, 37]), Op::Store(vec![4, 5, 6, 7, 8, 9, 4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Call(117, vec![36, 3, 37, 38, 39, 40], 1, false), Op::Call(77, vec![41], 32, false), Op::Store(vec![42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73])], ctrl: Ctrl::Return(0, vec![74]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 40, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_120() -> Function { + Function { body: Block { ops: vec![Op::Call(113, vec![1, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(119, vec![0, 1, 2], 1, false), Op::Call(111, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_121() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(121, vec![3], 1, false), Op::Mul(4, 5), Op::Add(2, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_122() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(0, vec![3, 9], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(122, vec![7, 1], 1, false), Op::Store(vec![15, 3, 4, 5, 6, 16])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 9), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::AssertEq(vec![6], vec![12], None), Op::AssertEq(vec![5], vec![11], None), Op::Const(G::from_u64(0)), Op::Call(122, vec![7, 13], 1, false), Op::Store(vec![17, 3, 4, 5, 6, 18])], ctrl: Ctrl::Return(3, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(122, vec![0, 13], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 18])], ctrl: Ctrl::Return(4, vec![19]) }))) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_123() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14, 14, 14, 14]), Op::Store(vec![13, 2, 3, 4, 5, 15])], ctrl: Ctrl::Return(1, vec![16, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(123, vec![12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 13]), Op::Store(vec![15, 8, 9, 10, 11, 14])], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 17, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_124() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(123, vec![0], 2, false), Op::Call(124, vec![13], 1, false), Op::Call(124, vec![14], 1, false), Op::Call(122, vec![15, 16], 1, false)], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 18, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_125() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(296, vec![1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], None), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(119, vec![8, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(121, vec![5], 1, false), Op::Call(125, vec![6, 9, 2, 3], 1, false), Op::Store(vec![11, 12, 5, 8, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 11, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_126() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(121, vec![12], 1, false), Op::Load(6, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(121, vec![22], 1, false), Op::Sub(13, 23), Op::EqZero(24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Call(115, vec![7, 2, 3], 1, false), Op::Call(115, vec![17, 2, 3], 1, false), Op::AssertEq(vec![26], vec![27], None), Op::Call(111, vec![8, 18], 1, false), Op::Call(120, vec![7, 2, 3, 28], 1, false), Op::Call(126, vec![19, 1, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![32, 13, 12, 7, 29, 30])], ctrl: Ctrl::Return(1, vec![33, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Call(112, vec![11, 8, 27], 1, false), Op::Call(120, vec![7, 2, 3, 29], 1, false), Op::Call(126, vec![9, 28, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![33, 13, 12, 7, 30, 31])], ctrl: Ctrl::Return(2, vec![34, 32]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(112, vec![11, 8, 21], 1, false), Op::Call(120, vec![7, 2, 3, 23], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26, 26, 26, 26]), Op::Store(vec![25, 13, 12, 7, 24, 27])], ctrl: Ctrl::Return(3, vec![28, 22]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 32, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_127() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 4), Op::Call(126, vec![0, 1, 2, 5], 2, false), Op::Call(127, vec![6, 7, 2, 5], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_128() -> Function { + Function { body: Block { ops: vec![Op::Call(296, vec![1], 1, false), Op::Call(296, vec![3], 1, false), Op::Sub(6, 7), Op::EqZero(8), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], None), Op::Call(125, vec![3, 1, 2, 5], 1, false), Op::Call(124, vec![11], 1, false), Op::Call(127, vec![12, 4, 2, 5], 2, false), Op::Call(296, vec![14], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![15], vec![16], None), Op::Load(6, 13)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Call(299, vec![22], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![0, 18], 1, false), Op::Sub(25, 21), Op::EqZero(26)], ctrl: Ctrl::Return(0, vec![27]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 20, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_129() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 1]), Op::Call(129, vec![4, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_130() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(0, 0), Op::Call(130, vec![5, 4], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 6)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_131() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 8), Op::Call(186, vec![9], 1, false), Op::Store(vec![8, 8, 8]), Op::Call(129, vec![0, 11], 1, false), Op::Call(130, vec![10, 12], 1, false), Op::Add(13, 13), Op::Add(4, 6), Op::Add(5, 7), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Mul(17, 17), Op::Const(G::from_u64(7)), Op::Mul(18, 18), Op::Mul(20, 21), Op::Sub(19, 22), Op::UnconstrainedGInverse(23), Op::Mul(23, 24), Op::Sub(25, 8), Op::Mul(23, 26), Op::AssertEq(vec![27], vec![18], None), Op::Mul(24, 26), Op::AssertEq(vec![28], vec![18], None), Op::Mul(17, 24), Op::Sub(18, 18), Op::Mul(30, 24), Op::Mul(15, 29), Op::Mul(16, 31), Op::Mul(20, 33), Op::Add(32, 34), Op::Mul(15, 31), Op::Mul(16, 29), Op::Add(36, 37), Op::Sub(4, 6), Op::Sub(5, 7), Op::Mul(14, 14), Op::Sub(41, 22), Op::UnconstrainedGInverse(42), Op::Mul(42, 43), Op::Sub(44, 8), Op::Mul(42, 45), Op::AssertEq(vec![46], vec![18], None), Op::Mul(43, 45), Op::AssertEq(vec![47], vec![18], None), Op::Mul(14, 43), Op::Mul(30, 43), Op::Mul(39, 48), Op::Mul(40, 49), Op::Mul(20, 51), Op::Add(50, 52), Op::Mul(39, 49), Op::Mul(40, 48), Op::Add(54, 55), Op::Mul(2, 53), Op::Mul(3, 56), Op::Mul(20, 58), Op::Add(57, 59), Op::Mul(2, 56), Op::Mul(3, 53), Op::Add(61, 62), Op::Add(35, 60), Op::Add(38, 63)], ctrl: Ctrl::Return(0, vec![64, 65]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 25, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_132() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(7)), Op::Call(186, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(129, vec![0, 5], 1, false), Op::Call(130, vec![3, 6], 1, false), Op::Mul(2, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_133() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(22, 10), Op::Const(G::from_u64(65536)), Op::Mul(24, 11), Op::Const(G::from_u64(16777216)), Op::Mul(26, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(28, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(30, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(32, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(34, 16), Op::Add(33, 35), Op::Add(31, 36), Op::Add(29, 37), Op::Add(27, 38), Op::Add(25, 39), Op::Add(23, 40), Op::Add(9, 41), Op::Const(G::from_u64(0)), Op::Sub(19, 42), Op::Sub(20, 43), Op::Mul(6, 44), Op::Const(G::from_u64(7)), Op::Mul(7, 45), Op::Mul(47, 48), Op::Add(46, 49), Op::Mul(6, 45), Op::Mul(7, 44), Op::Add(51, 52), Op::Add(4, 50), Op::Add(5, 53), Op::Mul(6, 2), Op::Mul(7, 3), Op::Mul(47, 57), Op::Add(56, 58), Op::Mul(6, 3), Op::Mul(7, 2), Op::Add(60, 61), Op::Call(133, vec![17, 21, 2, 3, 54, 55, 59, 62], 4, false)], ctrl: Ctrl::Return(1, vec![63, 64, 65, 66]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_134() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::U8RangeCheck(12, 13), Op::Const(G::from_u64(256)), Op::Mul(14, 7), Op::Const(G::from_u64(65536)), Op::Mul(16, 8), Op::Const(G::from_u64(16777216)), Op::Mul(18, 9), Op::Const(G::from_u64(4294967296)), Op::Mul(20, 10), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 11), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 12), Op::Const(G::from_u64(72057594037927936)), Op::Mul(26, 13), Op::Add(25, 27), Op::Add(23, 28), Op::Add(21, 29), Op::Add(19, 30), Op::Add(17, 31), Op::Add(15, 32), Op::Add(6, 33), Op::AssertEq(vec![34], vec![3], None), Op::Const(G::from_u64(1020)), Op::Sub(13, 35), Op::Add(12, 36), Op::Add(11, 37), Op::Add(10, 38), Op::EqZero(39), Op::Add(8, 9), Op::Add(7, 41), Op::Add(6, 42), Op::EqZero(43), Op::Const(G::from_u64(1)), Op::Sub(45, 44), Op::Mul(40, 46), Op::Sub(45, 47), Op::AssertEq(vec![48], vec![45], None), Op::UnconstrainedGToBytes(4), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::U8RangeCheck(55, 56), Op::Mul(14, 50), Op::Mul(16, 51), Op::Mul(18, 52), Op::Mul(20, 53), Op::Mul(22, 54), Op::Mul(24, 55), Op::Mul(26, 56), Op::Add(62, 63), Op::Add(61, 64), Op::Add(60, 65), Op::Add(59, 66), Op::Add(58, 67), Op::Add(57, 68), Op::Add(49, 69), Op::AssertEq(vec![70], vec![4], None), Op::Sub(56, 35), Op::Add(55, 71), Op::Add(54, 72), Op::Add(53, 73), Op::EqZero(74), Op::Add(51, 52), Op::Add(50, 76), Op::Add(49, 77), Op::EqZero(78), Op::Sub(45, 79), Op::Mul(75, 80), Op::Sub(45, 81), Op::AssertEq(vec![82], vec![45], None), Op::Call(134, vec![5, 1], 1, false), Op::Call(171, vec![49, 50, 51, 52, 53, 54, 55, 56, 83], 1, false), Op::Call(171, vec![6, 7, 8, 9, 10, 11, 12, 13, 84], 1, false)], ctrl: Ctrl::Return(1, vec![85]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 34, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_135() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(135, vec![4, 1], 1, false), Op::Call(134, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_136() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(136, vec![4, 1], 1, false), Op::Call(135, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_137() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(136, vec![1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_138() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(180, vec![0, 5, 6, 6, 6, 6, 6, 6, 6], 1, false), Op::Call(138, vec![7, 4], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_139() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![0, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Call(179, vec![10, 12, 9], 3, false), Op::Call(121, vec![13], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![14, 15]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_140() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(181, vec![0, 5], 1, false), Op::Call(139, vec![17, 8, 9, 10, 11, 12, 13, 14, 15, 3], 2, false), Op::Call(177, vec![18, 19], 18, false), Op::Call(140, vec![36, 6, 16, 3], 2, false), Op::Const(G::from_u64(256)), Op::Mul(40, 21), Op::Const(G::from_u64(65536)), Op::Mul(42, 22), Op::Const(G::from_u64(16777216)), Op::Mul(44, 23), Op::Const(G::from_u64(4294967296)), Op::Mul(46, 24), Op::Const(G::from_u64(1099511627776)), Op::Mul(48, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(50, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(52, 27), Op::Add(51, 53), Op::Add(49, 54), Op::Add(47, 55), Op::Add(45, 56), Op::Add(43, 57), Op::Add(41, 58), Op::Add(20, 59), Op::Const(G::from_u64(0)), Op::Mul(40, 29), Op::Mul(42, 30), Op::Mul(44, 31), Op::Mul(46, 32), Op::Mul(48, 33), Op::Mul(50, 34), Op::Mul(52, 35), Op::Add(67, 68), Op::Add(66, 69), Op::Add(65, 70), Op::Add(64, 71), Op::Add(63, 72), Op::Add(62, 73), Op::Add(28, 74), Op::Store(vec![61, 60, 75, 38])], ctrl: Ctrl::Return(1, vec![76, 39]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 38, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_141() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![0, 3], 1, false), Op::Sub(1, 4), Op::Add(5, 6), Op::EqZero(7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 9), Op::Add(3, 9), Op::Call(141, vec![0, 1, 10, 11, 4], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_142() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(141, vec![0, 1, 2, 4, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 6), Op::Call(142, vec![0, 1, 2, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(142, vec![0, 1, 2, 8], 1, false), Op::Store(vec![6, 3, 7, 6, 6, 6, 9])], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_143() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![16]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(9, 1), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(133, vec![2, 3, 6, 7, 17, 17, 10, 11], 4, false), Op::Mul(4, 18), Op::Const(G::from_u64(7)), Op::Mul(5, 19), Op::Mul(23, 24), Op::Add(22, 25), Op::Mul(4, 19), Op::Mul(5, 18), Op::Add(27, 28), Op::Add(12, 26), Op::Add(13, 29), Op::Store(vec![17, 9, 20, 21, 30, 31, 14])], ctrl: Ctrl::Return(1, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(143, vec![14, 1, 2, 3, 4, 5, 6, 7], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 13, 18])], ctrl: Ctrl::Return(2, vec![19]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_144() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 1), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(6, 11), Op::EqZero(12), Op::Sub(7, 11), Op::EqZero(14), Op::Mul(13, 15), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(144, vec![8, 1], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_145() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_146() -> Function { + Function { body: Block { ops: vec![Op::Call(301, vec![6], 1, false), Op::Call(297, vec![7], 1, false), Op::Sub(10, 11), Op::EqZero(12), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], None), Op::Sub(3, 1), Op::Call(308, vec![2, 15], 1, false), Op::Const(G::from_u64(7)), Op::Call(186, vec![1], 1, false), Op::Store(vec![14, 14, 14]), Op::Call(129, vec![16, 19], 1, false), Op::Call(130, vec![18, 20], 1, false), Op::Mul(17, 21), Op::Const(G::from_u64(0)), Op::Sub(4, 22), Op::Sub(5, 23), Op::Mul(24, 24), Op::Mul(25, 25), Op::Mul(17, 27), Op::Sub(26, 28), Op::UnconstrainedGInverse(29), Op::Mul(29, 30), Op::Sub(31, 14), Op::Mul(29, 32), Op::AssertEq(vec![33], vec![23], None), Op::Mul(30, 32), Op::AssertEq(vec![34], vec![23], None), Op::Mul(24, 30), Op::Sub(23, 25), Op::Mul(36, 30), Op::Call(143, vec![0, 1, 6, 7, 35, 37, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![38]) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_147() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![8, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(294, vec![8, 13], 1, false), Op::Call(186, vec![4], 1, false), Op::Mul(5, 15), Op::Const(G::from_u64(7)), Op::Mul(6, 11), Op::Mul(17, 18), Op::Add(16, 19), Op::Mul(5, 11), Op::Mul(6, 15), Op::Add(21, 22), Op::Call(146, vec![0, 3, 1, 2, 5, 6, 7, 12, 9, 10], 1, false), Op::Call(146, vec![24, 3, 1, 2, 20, 23, 7, 14, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![25]) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_148() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(294, vec![9, 4], 1, false), Op::Call(294, vec![10, 4], 1, false), Op::Call(147, vec![0, 1, 2, 14, 13, 7, 8, 15, 16, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 18), Op::Sub(5, 18), Op::Call(148, vec![17, 1, 2, 3, 19, 20, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![21]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_149() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(294, vec![9, 4], 1, false), Op::Call(294, vec![10, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![16, 17], 1, false), Op::Call(146, vec![0, 14, 1, 2, 7, 8, 15, 18, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 20), Op::Sub(5, 20), Op::Call(149, vec![19, 1, 2, 3, 21, 22, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![23]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 8, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_150() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(305, vec![8, 4], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 17), Op::Sub(5, 17), Op::Call(150, vec![0, 1, 2, 3, 18, 19, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![20]) }), (G::from_u64(1), Block { ops: vec![Op::Call(294, vec![7, 4], 1, false), Op::Add(17, 3), Op::Call(294, vec![11, 6], 1, false), Op::Call(294, vec![12, 6], 1, false), Op::Call(147, vec![0, 1, 2, 18, 17, 9, 10, 19, 20, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 22), Op::Sub(5, 22), Op::Add(6, 22), Op::Call(150, vec![21, 1, 2, 3, 23, 24, 25, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(2, vec![26]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_151() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(294, vec![1, 15], 1, false)], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![16], 1, false), Op::Call(296, vec![4], 1, false), Op::Sub(17, 18), Op::EqZero(19), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Const(G::from_u64(0)), Op::Call(154, vec![6, 10, 5, 7, 22], 1, false), Op::Call(153, vec![23], 1, false), Op::Call(150, vec![0, 8, 9, 10, 22, 7, 22, 6, 5, 11, 12, 16, 4, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_152() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![0, 3], 1, false), Op::Add(5, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Add(3, 7), Op::Call(152, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_153() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(153, vec![3], 1, false), Op::U32LessThan(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_154() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(305, vec![2, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Add(4, 7), Op::Call(154, vec![0, 1, 2, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![0, 4], 1, false), Op::Add(8, 1), Op::Const(G::from_u64(1)), Op::Sub(3, 10), Op::Add(4, 10), Op::Call(154, vec![0, 1, 2, 11, 12], 1, false), Op::Store(vec![7, 9, 13])], ctrl: Ctrl::Return(2, vec![14]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_155() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 1, 2]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_156() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Const(G::from_u64(256)), Op::Mul(12, 5), Op::Const(G::from_u64(65536)), Op::Mul(14, 6), Op::Const(G::from_u64(16777216)), Op::Mul(16, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 11), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(4, 31), Op::AssertEq(vec![32], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(11, 33), Op::Add(10, 34), Op::Add(9, 35), Op::Add(8, 36), Op::EqZero(37), Op::Add(6, 7), Op::Add(5, 39), Op::Add(4, 40), Op::EqZero(41), Op::Const(G::from_u64(1)), Op::Sub(43, 42), Op::Mul(38, 44), Op::Sub(43, 45), Op::AssertEq(vec![46], vec![43], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(47, 48), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::Mul(12, 48), Op::Mul(14, 49), Op::Mul(16, 50), Op::Mul(18, 51), Op::Mul(20, 52), Op::Mul(22, 53), Op::Mul(24, 54), Op::Add(60, 61), Op::Add(59, 62), Op::Add(58, 63), Op::Add(57, 64), Op::Add(56, 65), Op::Add(55, 66), Op::Add(47, 67), Op::AssertEq(vec![68], vec![1], None), Op::Sub(54, 33), Op::Add(53, 69), Op::Add(52, 70), Op::Add(51, 71), Op::EqZero(72), Op::Add(49, 50), Op::Add(48, 74), Op::Add(47, 75), Op::EqZero(76), Op::Sub(43, 77), Op::Mul(73, 78), Op::Sub(43, 79), Op::AssertEq(vec![80], vec![43], None), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(81, 82), Op::U8RangeCheck(83, 84), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::Mul(12, 82), Op::Mul(14, 83), Op::Mul(16, 84), Op::Mul(18, 85), Op::Mul(20, 86), Op::Mul(22, 87), Op::Mul(24, 88), Op::Add(94, 95), Op::Add(93, 96), Op::Add(92, 97), Op::Add(91, 98), Op::Add(90, 99), Op::Add(89, 100), Op::Add(81, 101), Op::AssertEq(vec![102], vec![2], None), Op::Sub(88, 33), Op::Add(87, 103), Op::Add(86, 104), Op::Add(85, 105), Op::EqZero(106), Op::Add(83, 84), Op::Add(82, 108), Op::Add(81, 109), Op::EqZero(110), Op::Sub(43, 111), Op::Mul(107, 112), Op::Sub(43, 113), Op::AssertEq(vec![114], vec![43], None), Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(115, 116), Op::U8RangeCheck(117, 118), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::Mul(12, 116), Op::Mul(14, 117), Op::Mul(16, 118), Op::Mul(18, 119), Op::Mul(20, 120), Op::Mul(22, 121), Op::Mul(24, 122), Op::Add(128, 129), Op::Add(127, 130), Op::Add(126, 131), Op::Add(125, 132), Op::Add(124, 133), Op::Add(123, 134), Op::Add(115, 135), Op::AssertEq(vec![136], vec![3], None), Op::Sub(122, 33), Op::Add(121, 137), Op::Add(120, 138), Op::Add(119, 139), Op::EqZero(140), Op::Add(117, 118), Op::Add(116, 142), Op::Add(115, 143), Op::EqZero(144), Op::Sub(43, 145), Op::Mul(141, 146), Op::Sub(43, 147), Op::AssertEq(vec![148], vec![43], None), Op::Const(G::from_u64(0)), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Store(vec![149, 115, 116, 117, 118, 119, 120, 121, 122, 150]), Op::Store(vec![149, 81, 82, 83, 84, 85, 86, 87, 88, 151]), Op::Store(vec![149, 47, 48, 49, 50, 51, 52, 53, 54, 152]), Op::Store(vec![149, 4, 5, 6, 7, 8, 9, 10, 11, 153])], ctrl: Ctrl::Return(0, vec![154]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 58, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_157() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(7, 2), Op::EqZero(13)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(185, vec![3, 4, 15], 2, false), Op::Mul(16, 10), Op::Const(G::from_u64(7)), Op::Mul(17, 11), Op::Mul(19, 20), Op::Add(18, 21), Op::Mul(16, 11), Op::Mul(17, 10), Op::Add(23, 24), Op::Add(0, 22), Op::Add(1, 25)], ctrl: Ctrl::Return(1, vec![26, 27, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 1, 5]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 16, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_158() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Sub(6, 8), Op::EqZero(13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], None), Op::Call(300, vec![7], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(0, vec![0, 1, 18]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(297, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Load(3, 5)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(6, 25), Op::Const(G::from_u64(0)), Op::Call(305, vec![11, 27], 2, false)], ctrl: Ctrl::MatchContinue(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![0, 1, 28, 29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![28, 29, 0, 1]) })), 4, 1, 0, Box::new(Block { ops: vec![Op::Call(131, vec![24, 26, 14, 15, 30, 31, 32, 33], 2, false), Op::Call(157, vec![34, 35, 26, 14, 15, 7], 3, false), Op::Call(158, vec![36, 37, 16, 19, 12, 24, 26, 38, 8], 3, false), Op::UnconstrainedGToBytes(30), Op::U8RangeCheck(42, 43), Op::U8RangeCheck(44, 45), Op::U8RangeCheck(46, 47), Op::U8RangeCheck(48, 49), Op::Const(G::from_u64(256)), Op::Mul(50, 43), Op::Const(G::from_u64(65536)), Op::Mul(52, 44), Op::Const(G::from_u64(16777216)), Op::Mul(54, 45), Op::Const(G::from_u64(4294967296)), Op::Mul(56, 46), Op::Const(G::from_u64(1099511627776)), Op::Mul(58, 47), Op::Const(G::from_u64(281474976710656)), Op::Mul(60, 48), Op::Const(G::from_u64(72057594037927936)), Op::Mul(62, 49), Op::Add(61, 63), Op::Add(59, 64), Op::Add(57, 65), Op::Add(55, 66), Op::Add(53, 67), Op::Add(51, 68), Op::Add(42, 69), Op::AssertEq(vec![70], vec![30], None), Op::Const(G::from_u64(1020)), Op::Sub(49, 71), Op::Add(48, 72), Op::Add(47, 73), Op::Add(46, 74), Op::EqZero(75), Op::Add(44, 45), Op::Add(43, 77), Op::Add(42, 78), Op::EqZero(79), Op::Const(G::from_u64(1)), Op::Sub(81, 80), Op::Mul(76, 82), Op::Sub(81, 83), Op::AssertEq(vec![84], vec![81], None), Op::UnconstrainedGToBytes(31), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::U8RangeCheck(89, 90), Op::U8RangeCheck(91, 92), Op::Mul(50, 86), Op::Mul(52, 87), Op::Mul(54, 88), Op::Mul(56, 89), Op::Mul(58, 90), Op::Mul(60, 91), Op::Mul(62, 92), Op::Add(98, 99), Op::Add(97, 100), Op::Add(96, 101), Op::Add(95, 102), Op::Add(94, 103), Op::Add(93, 104), Op::Add(85, 105), Op::AssertEq(vec![106], vec![31], None), Op::Sub(92, 71), Op::Add(91, 107), Op::Add(90, 108), Op::Add(89, 109), Op::EqZero(110), Op::Add(87, 88), Op::Add(86, 112), Op::Add(85, 113), Op::EqZero(114), Op::Sub(81, 115), Op::Mul(111, 116), Op::Sub(81, 117), Op::AssertEq(vec![118], vec![81], None), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::U8RangeCheck(123, 124), Op::U8RangeCheck(125, 126), Op::Mul(50, 120), Op::Mul(52, 121), Op::Mul(54, 122), Op::Mul(56, 123), Op::Mul(58, 124), Op::Mul(60, 125), Op::Mul(62, 126), Op::Add(132, 133), Op::Add(131, 134), Op::Add(130, 135), Op::Add(129, 136), Op::Add(128, 137), Op::Add(127, 138), Op::Add(119, 139), Op::AssertEq(vec![140], vec![32], None), Op::Sub(126, 71), Op::Add(125, 141), Op::Add(124, 142), Op::Add(123, 143), Op::EqZero(144), Op::Add(121, 122), Op::Add(120, 146), Op::Add(119, 147), Op::EqZero(148), Op::Sub(81, 149), Op::Mul(145, 150), Op::Sub(81, 151), Op::AssertEq(vec![152], vec![81], None), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(153, 154), Op::U8RangeCheck(155, 156), Op::U8RangeCheck(157, 158), Op::U8RangeCheck(159, 160), Op::Mul(50, 154), Op::Mul(52, 155), Op::Mul(54, 156), Op::Mul(56, 157), Op::Mul(58, 158), Op::Mul(60, 159), Op::Mul(62, 160), Op::Add(166, 167), Op::Add(165, 168), Op::Add(164, 169), Op::Add(163, 170), Op::Add(162, 171), Op::Add(161, 172), Op::Add(153, 173), Op::AssertEq(vec![174], vec![33], None), Op::Sub(160, 71), Op::Add(159, 175), Op::Add(158, 176), Op::Add(157, 177), Op::EqZero(178), Op::Add(155, 156), Op::Add(154, 180), Op::Add(153, 181), Op::EqZero(182), Op::Sub(81, 183), Op::Mul(179, 184), Op::Sub(81, 185), Op::AssertEq(vec![186], vec![81], None), Op::Const(G::from_u64(0)), Op::Store(vec![81, 81, 81, 81, 81, 81, 81, 81, 81, 81]), Op::Store(vec![187, 153, 154, 155, 156, 157, 158, 159, 160, 188]), Op::Store(vec![187, 119, 120, 121, 122, 123, 124, 125, 126, 189]), Op::Store(vec![187, 85, 86, 87, 88, 89, 90, 91, 92, 190]), Op::Store(vec![187, 42, 43, 44, 45, 46, 47, 48, 49, 191]), Op::Store(vec![187, 192, 41])], ctrl: Ctrl::Return(3, vec![39, 40, 193]) })) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 89, lookups: 32 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_159() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(297, vec![2], 1, false), Op::Sub(25, 24), Op::EqZero(26), Op::Const(G::from_u64(1)), Op::AssertEq(vec![27], vec![28], None), Op::Call(296, vec![1], 1, false), Op::Const(G::from_u64(3)), Op::Call(145, vec![8, 9], 1, false), Op::Add(30, 31), Op::Sub(29, 32), Op::EqZero(33), Op::AssertEq(vec![34], vec![28], None), Op::Call(142, vec![15, 19, 18, 20], 1, false), Op::Const(G::from_u64(0)), Op::Call(152, vec![15, 19, 18, 36], 1, false), Op::Call(294, vec![1, 36], 1, false)], ctrl: Ctrl::Match(38, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![38], 1, false), Op::Sub(39, 18), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::AssertEq(vec![41], vec![42], None), Op::Const(G::from_u64(0)), Op::Call(148, vec![35, 0, 20, 19, 43, 18, 15, 16, 17, 38, 5, 3, 4], 1, false), Op::Call(294, vec![1, 42], 1, false)], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![45], 1, false), Op::Sub(46, 18), Op::EqZero(47), Op::Const(G::from_u64(1)), Op::AssertEq(vec![48], vec![49], None), Op::Const(G::from_u64(0)), Op::Call(148, vec![44, 0, 20, 19, 50, 18, 15, 16, 17, 45, 6, 3, 4], 1, false), Op::Const(G::from_u64(2)), Op::Call(294, vec![1, 52], 1, false)], ctrl: Ctrl::Match(53, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![53], 1, false), Op::Sub(54, 18), Op::EqZero(55), Op::Const(G::from_u64(1)), Op::AssertEq(vec![56], vec![57], None), Op::Const(G::from_u64(0)), Op::Call(149, vec![51, 0, 20, 19, 58, 18, 15, 16, 17, 53, 7, 3, 4], 1, false), Op::Call(151, vec![59, 1, 13, 8, 9, 14, 15, 18, 0, 20, 19, 16, 17, 3, 4], 1, false), Op::Call(144, vec![60, 19], 1, false), Op::Load(7, 60)], ctrl: Ctrl::Match(62, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(63, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(63, 20), Op::EqZero(69), Op::Const(G::from_u64(1)), Op::AssertEq(vec![70], vec![71], None), Op::Call(158, vec![66, 67, 21, 22, 2, 0, 20, 68, 19], 3, false), Op::Const(G::from_u64(0)), Op::Call(305, vec![23, 75], 2, false), Op::Sub(76, 72), Op::EqZero(78), Op::Sub(77, 73), Op::EqZero(80), Op::Mul(79, 81), Op::AssertEq(vec![82], vec![71], None)], ctrl: Ctrl::Return(0, vec![74]) }))) })].into_iter().collect(), None) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 25, selectors: 1, auxiliaries: 46, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_160() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29])], ctrl: Ctrl::Return(0, vec![30]) }), (G::from_u64(0), Block { ops: vec![Op::Call(179, vec![0, 1, 20], 3, false), Op::Call(159, vec![29, 26, 27, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Const(G::from_u64(0)), Op::Call(160, vec![30, 31, 28, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Store(vec![33, 32, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 25, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_161() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![0, 1, 3], 3, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(161, vec![5, 6, 9, 3], 1, false), Op::Store(vec![7, 4, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_162() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![3, 1], 1, false), Op::Call(162, vec![5, 1], 1, false), Op::Store(vec![6, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_163() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![4, 1], 1, false), Op::Call(163, vec![6, 1], 1, false), Op::Store(vec![7, 3, 8, 9])], ctrl: Ctrl::Return(1, vec![10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_164() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(162, vec![0, 2], 1, false), Op::Call(163, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Sub(3, 7), Op::Call(164, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 5, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_165() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(152, vec![9, 11, 10, 13], 1, false), Op::Call(305, vec![0, 13], 2, false)], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(305, vec![0, 17], 2, false)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(305, vec![0, 20], 2, false)], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(128, vec![2, 15, 14, 1, 16, 12], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![23], vec![24], None), Op::Call(128, vec![3, 18, 14, 1, 19, 12], 1, false), Op::AssertEq(vec![25], vec![24], None), Op::Call(128, vec![4, 21, 14, 1, 22, 12], 1, false), Op::AssertEq(vec![26], vec![24], None)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(305, vec![0, 27], 2, false)], ctrl: Ctrl::Match(28, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(154, vec![9, 11, 8, 10, 30], 1, false), Op::Call(153, vec![31], 1, false), Op::Sub(12, 32), Op::Call(166, vec![1, 33], 1, false), Op::Call(128, vec![5, 28, 31, 34, 29, 32], 1, false)], ctrl: Ctrl::Return(1, vec![35]) }))) })].into_iter().collect(), None) }))) }))) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 17, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_166() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(308, vec![3, 1], 1, false), Op::Call(166, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_167() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![3, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![5, 6, 8]), Op::Call(167, vec![4, 1], 1, false), Op::Store(vec![5, 9, 10])], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_168() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(296, vec![1], 1, false), Op::EqZero(11)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![14], None), Op::Call(296, vec![8], 1, false), Op::Call(296, vec![3], 1, false), Op::AssertEq(vec![15], vec![16], None), Op::Call(166, vec![3, 14], 1, false), Op::Sub(5, 14), Op::Call(167, vec![2, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14]), Op::Store(vec![20, 18, 21]), Op::Call(128, vec![12, 19, 22, 17, 9, 18], 1, false), Op::AssertEq(vec![23], vec![14], None), Op::Add(4, 14), Op::Call(168, vec![10, 13, 2, 17, 24, 18], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 17, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_169() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![6], 1, false), Op::Call(301, vec![7], 1, false), Op::Sub(33, 32), Op::EqZero(34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(297, vec![8], 1, false), Op::Const(G::from_u64(3)), Op::Call(145, vec![4, 5], 1, false), Op::Add(38, 39), Op::AssertEq(vec![37], vec![40], None), Op::Call(307, vec![9], 1, false), Op::Sub(41, 32), Op::EqZero(42), Op::AssertEq(vec![43], vec![36], None), Op::Call(297, vec![10], 1, false), Op::AssertEq(vec![44], vec![36], None), Op::Store(vec![36, 36, 36])], ctrl: Ctrl::MatchContinue(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![45]) }), (G::from_u64(1), Block { ops: vec![Op::Call(136, vec![5, 45], 1, false)], ctrl: Ctrl::Yield(1, vec![46]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(136, vec![3, 46], 1, false), Op::Call(136, vec![2, 47], 1, false), Op::Call(136, vec![1, 48], 1, false), Op::Call(298, vec![0, 49], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51]), Op::Call(177, vec![50, 52], 18, false), Op::Const(G::from_u64(256)), Op::Mul(71, 54), Op::Const(G::from_u64(65536)), Op::Mul(73, 55), Op::Const(G::from_u64(16777216)), Op::Mul(75, 56), Op::Const(G::from_u64(4294967296)), Op::Mul(77, 57), Op::Const(G::from_u64(1099511627776)), Op::Mul(79, 58), Op::Const(G::from_u64(281474976710656)), Op::Mul(81, 59), Op::Const(G::from_u64(72057594037927936)), Op::Mul(83, 60), Op::Add(82, 84), Op::Add(80, 85), Op::Add(78, 86), Op::Add(76, 87), Op::Add(74, 88), Op::Add(72, 89), Op::Add(53, 90), Op::Mul(71, 62), Op::Mul(73, 63), Op::Mul(75, 64), Op::Mul(77, 65), Op::Mul(79, 66), Op::Mul(81, 67), Op::Mul(83, 68), Op::Add(97, 98), Op::Add(96, 99), Op::Add(95, 100), Op::Add(94, 101), Op::Add(93, 102), Op::Add(92, 103), Op::Add(61, 104), Op::Call(140, vec![69, 6, 7, 30], 2, false), Op::Call(134, vec![10, 52], 1, false), Op::Call(298, vec![107, 108], 1, false), Op::Call(138, vec![109, 6], 1, false), Op::Call(139, vec![110, 11, 12, 13, 14, 15, 16, 17, 18, 31], 2, false), Op::Add(32, 28), Op::Const(G::from_u64(33)), Op::U32LessThan(113, 114), Op::AssertEq(vec![115], vec![51], None), Op::Call(161, vec![111, 112, 29, 113], 1, false), Op::Call(165, vec![8, 116, 19, 20, 21, 22, 4, 5, 23, 24, 27, 28, 113], 1, false), Op::AssertEq(vec![117], vec![51], None), Op::Const(G::from_u64(0)), Op::Call(164, vec![8, 9, 118, 29], 1, false), Op::Call(160, vec![111, 112, 119, 91, 105, 1, 2, 3, 4, 5, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 113, 106, 6, 10, 32], 1, false), Op::Call(168, vec![9, 6, 120, 116, 118, 113], 1, false)], ctrl: Ctrl::Return(2, vec![121]) })) }))) }, layout: FunctionLayout { input_size: 32, selectors: 3, auxiliaries: 55, lookups: 31 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_170() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::EqZero(1), Op::Mul(2, 3)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_171() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 7, 8]), Op::Store(vec![9, 6, 10]), Op::Store(vec![9, 5, 11]), Op::Store(vec![9, 4, 12]), Op::Store(vec![9, 3, 13]), Op::Store(vec![9, 2, 14]), Op::Store(vec![9, 1, 15]), Op::Store(vec![9, 0, 16])], ctrl: Ctrl::Return(0, vec![17]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_172() -> Function { + Function { body: Block { ops: vec![Op::Call(171, vec![24, 25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Call(171, vec![16, 17, 18, 19, 20, 21, 22, 23, 33], 1, false), Op::Call(171, vec![8, 9, 10, 11, 12, 13, 14, 15, 34], 1, false), Op::Call(171, vec![0, 1, 2, 3, 4, 5, 6, 7, 35], 1, false)], ctrl: Ctrl::Return(0, vec![36]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_173() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Call(173, vec![4, 1], 1, false), Op::Call(171, vec![29, 30, 31, 32, 33, 34, 35, 36, 37], 1, false), Op::Call(171, vec![21, 22, 23, 24, 25, 26, 27, 28, 38], 1, false), Op::Call(171, vec![13, 14, 15, 16, 17, 18, 19, 20, 39], 1, false), Op::Call(171, vec![5, 6, 7, 8, 9, 10, 11, 12, 40], 1, false)], ctrl: Ctrl::Return(1, vec![41]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 41, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_174() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(174, vec![4, 1], 1, false), Op::Call(171, vec![3, 5, 5, 5, 5, 5, 5, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_175() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Const(G::from_u64(0)), Op::Store(vec![38, 38, 38, 38, 38, 38, 38, 38]), Op::Store(vec![5, 6, 7, 8, 9, 10, 5, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36]), Op::Call(78, vec![0, 37, 38, 38, 39, 40, 41], 1, false), Op::Call(77, vec![42], 32, false), Op::Call(108, vec![71, 72, 73, 74, 37], 1, false), Op::Call(108, vec![67, 68, 69, 70, 75], 1, false), Op::Call(108, vec![63, 64, 65, 66, 76], 1, false), Op::Call(108, vec![59, 60, 61, 62, 77], 1, false), Op::Call(108, vec![55, 56, 57, 58, 78], 1, false), Op::Call(108, vec![51, 52, 53, 54, 79], 1, false), Op::Call(108, vec![47, 48, 49, 50, 80], 1, false), Op::Call(108, vec![43, 44, 45, 46, 81], 1, false), Op::Call(129, vec![82, 37], 1, false), Op::Load(3, 83)], ctrl: Ctrl::Match(84, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 89)], ctrl: Ctrl::Match(90, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(93, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 95)], ctrl: Ctrl::Match(96, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 98)], ctrl: Ctrl::Match(99, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 101)], ctrl: Ctrl::Match(102, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 104)], ctrl: Ctrl::Match(105, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![85, 88, 91, 94, 97, 100, 103, 106, 82, 107]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 22)], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 6, 9, 12, 15, 18, 21, 24, 0, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 74, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_176() -> Function { + Function { body: Block { ops: vec![Op::Call(175, vec![0, 1], 10, false), Op::Const(G::from_u64(1020)), Op::Sub(9, 12), Op::Add(8, 13), Op::Add(7, 14), Op::Add(6, 15), Op::EqZero(16), Op::Add(4, 5), Op::Add(3, 18), Op::Add(2, 19), Op::EqZero(20), Op::Const(G::from_u64(1)), Op::Sub(22, 21), Op::Mul(17, 23), Op::Sub(22, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![10, 11], 10, false)], ctrl: Ctrl::Return(1, vec![26, 27, 28, 29, 30, 31, 32, 33, 34, 35]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 27, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_177() -> Function { + Function { body: Block { ops: vec![Op::Call(176, vec![0, 1], 10, false), Op::Call(176, vec![10, 11], 10, false)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 21, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_178() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(178, vec![4, 7], 1, false), Op::Store(vec![5, 3, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_179() -> Function { + Function { body: Block { ops: vec![Op::Call(175, vec![0, 1], 10, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4), Op::U8BitDecomposition(5), Op::U8BitDecomposition(6), Op::Const(G::from_u64(1)), Op::Store(vec![45, 45, 45]), Op::Call(171, vec![37, 38, 39, 40, 41, 42, 43, 44, 46], 1, false), Op::Call(171, vec![29, 30, 31, 32, 33, 34, 35, 36, 47], 1, false), Op::Call(171, vec![21, 22, 23, 24, 25, 26, 27, 28, 48], 1, false), Op::Call(171, vec![13, 14, 15, 16, 17, 18, 19, 20, 49], 1, false), Op::Call(178, vec![50, 2], 1, false)], ctrl: Ctrl::Return(0, vec![51, 11, 12]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 49, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_180() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(171, vec![1, 2, 3, 4, 5, 6, 7, 8, 10], 1, false), Op::Call(298, vec![0, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_181() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(173, vec![1, 3], 1, false), Op::Call(298, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_182() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![1, 14, 0]), Op::Store(vec![1, 13, 15]), Op::Store(vec![1, 12, 16]), Op::Store(vec![1, 11, 17]), Op::Store(vec![1, 10, 18]), Op::Store(vec![1, 9, 19]), Op::Store(vec![1, 5, 20]), Op::Store(vec![1, 8, 21]), Op::Store(vec![1, 7, 22]), Op::Store(vec![1, 6, 23]), Op::Store(vec![1, 5, 24]), Op::Store(vec![1, 4, 25]), Op::Store(vec![1, 3, 26]), Op::Store(vec![1, 2, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 15 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_183() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(183, vec![11, 1], 1, false), Op::Call(171, vec![3, 4, 5, 6, 7, 8, 9, 10, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_184() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_185() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(4, 5), Op::Add(3, 6), Op::Mul(0, 1), Op::Mul(1, 0), Op::Add(8, 9), Op::Const(G::from_u64(1)), Op::Sub(2, 11), Op::Call(185, vec![7, 10, 12], 2, false)], ctrl: Ctrl::Return(1, vec![13, 14]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_186() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1753635133440165772))], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 1), Op::Call(186, vec![2], 1, false), Op::Mul(3, 3)], ctrl: Ctrl::Return(2, vec![4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_187() -> Function { + Function { body: Block { ops: vec![Op::Call(185, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6)], ctrl: Ctrl::Return(0, vec![7, 8]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_188() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Sub(0, 2), Op::Call(188, vec![3], 1, false), Op::Mul(1, 4)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_189() -> Function { + Function { body: Block { ops: vec![Op::Call(185, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6), Op::Call(186, vec![2], 1, false), Op::UnconstrainedGInverse(9), Op::Mul(9, 10), Op::Sub(11, 5), Op::Mul(9, 12), Op::AssertEq(vec![13], vec![6], None), Op::Mul(10, 12), Op::AssertEq(vec![14], vec![6], None), Op::Sub(0, 5), Op::Sub(1, 6), Op::Mul(15, 15), Op::Const(G::from_u64(7)), Op::Mul(16, 16), Op::Mul(18, 19), Op::Sub(17, 20), Op::UnconstrainedGInverse(21), Op::Mul(21, 22), Op::Sub(23, 5), Op::Mul(21, 24), Op::AssertEq(vec![25], vec![6], None), Op::Mul(22, 24), Op::AssertEq(vec![26], vec![6], None), Op::Mul(15, 22), Op::Sub(6, 16), Op::Mul(28, 22), Op::Mul(7, 27), Op::Mul(8, 29), Op::Mul(18, 31), Op::Add(30, 32), Op::Mul(7, 29), Op::Mul(8, 27), Op::Add(34, 35), Op::Sub(0, 10), Op::Mul(37, 37), Op::Sub(38, 20), Op::UnconstrainedGInverse(39), Op::Mul(39, 40), Op::Sub(41, 5), Op::Mul(39, 42), Op::AssertEq(vec![43], vec![6], None), Op::Mul(40, 42), Op::AssertEq(vec![44], vec![6], None), Op::Mul(37, 40), Op::Mul(28, 40), Op::Mul(7, 45), Op::Mul(8, 46), Op::Mul(18, 48), Op::Add(47, 49), Op::Mul(7, 46), Op::Mul(8, 45), Op::Add(51, 52), Op::Mul(7, 7), Op::Mul(8, 8), Op::Mul(18, 55), Op::Sub(54, 56), Op::UnconstrainedGInverse(57), Op::Mul(57, 58), Op::Sub(59, 5), Op::Mul(57, 60), Op::AssertEq(vec![61], vec![6], None), Op::Mul(58, 60), Op::AssertEq(vec![62], vec![6], None), Op::Mul(7, 58), Op::Sub(6, 8), Op::Mul(64, 58)], ctrl: Ctrl::Return(0, vec![33, 36, 50, 53, 37, 16, 63, 65]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 39, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_190() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(11, 12), Op::Add(10, 4), Op::Add(13, 5)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_191() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Mul(2, 4), Op::Const(G::from_u64(7)), Op::Mul(3, 5), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(11, 12), Op::Add(0, 10), Op::Add(1, 13)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_192() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(191, vec![2, 3, 6, 7], 2, false), Op::Call(192, vec![8], 1, false), Op::Store(vec![9, 10, 11, 12])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_193() -> Function { + Function { body: Block { ops: vec![Op::Call(303, vec![0, 1], 4, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![16, 19]) }), (G::from_u64(1), Block { ops: vec![Op::Add(16, 17), Op::Add(16, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(305, vec![4, 18], 2, false)], ctrl: Ctrl::Return(1, vec![21, 22]) }), (G::from_u64(1), Block { ops: vec![Op::Call(305, vec![5, 18], 2, false)], ctrl: Ctrl::Return(2, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(305, vec![2, 18], 2, false)], ctrl: Ctrl::Return(3, vec![21, 22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(305, vec![3, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }), (G::from_u64(4), Block { ops: vec![Op::Call(305, vec![6, 18], 2, false)], ctrl: Ctrl::Return(5, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(305, vec![7, 18], 2, false)], ctrl: Ctrl::Return(6, vec![21, 22]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(305, vec![8, 16], 2, false)], ctrl: Ctrl::Return(7, vec![19, 20]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(8, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(9, vec![11, 12]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(10, vec![13, 14]) }), (G::from_u64(6), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(193, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Add(19, 21), Op::Add(20, 22)], ctrl: Ctrl::Return(11, vec![23, 24]) }), (G::from_u64(7), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(193, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Sub(19, 21), Op::Sub(20, 22)], ctrl: Ctrl::Return(12, vec![23, 24]) }), (G::from_u64(8), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(193, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Mul(19, 21), Op::Const(G::from_u64(7)), Op::Mul(20, 22), Op::Mul(24, 25), Op::Add(23, 26), Op::Mul(19, 22), Op::Mul(20, 21), Op::Add(28, 29)], ctrl: Ctrl::Return(13, vec![27, 30]) }), (G::from_u64(9), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Const(G::from_u64(0)), Op::Sub(21, 19), Op::Sub(21, 20)], ctrl: Ctrl::Return(14, vec![22, 23]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_194() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(193, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Call(190, vec![0, 1, 2, 3, 22, 23], 2, false), Op::Call(194, vec![24, 25, 2, 3, 21, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_195() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 4), Op::Const(G::from_u64(7)), Op::Mul(1, 5), Op::Mul(9, 10), Op::Add(8, 11), Op::Mul(0, 5), Op::Mul(1, 4), Op::Add(13, 14), Op::Const(G::from_u64(0)), Op::Mul(2, 6), Op::Mul(3, 7), Op::Mul(9, 18), Op::Add(17, 19), Op::Mul(2, 7), Op::Mul(3, 6), Op::Add(21, 22), Op::Mul(9, 20), Op::Mul(16, 23), Op::Mul(9, 25), Op::Add(24, 26), Op::Mul(9, 23), Op::Mul(16, 20), Op::Add(28, 29), Op::Add(12, 27), Op::Add(15, 30), Op::Mul(0, 6), Op::Mul(1, 7), Op::Mul(9, 34), Op::Add(33, 35), Op::Mul(0, 7), Op::Mul(1, 6), Op::Add(37, 38), Op::Mul(2, 4), Op::Mul(3, 5), Op::Mul(9, 41), Op::Add(40, 42), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(44, 45), Op::Add(36, 43), Op::Add(39, 46)], ctrl: Ctrl::Return(0, vec![31, 32, 47, 48]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 17, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_196() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![22, 22, 22, 22]) }), (G::from_u64(0), Block { ops: vec![Op::Call(196, vec![21, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 4, false), Op::Call(195, vec![22, 23, 24, 25, 1, 2, 3, 4], 4, false), Op::Call(193, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Add(26, 30), Op::Add(27, 31)], ctrl: Ctrl::Return(1, vec![32, 33, 28, 29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 14, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_197() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(44, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(196, vec![46, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 4, false), Op::Add(48, 22), Op::Add(49, 23), Op::Add(50, 24), Op::Add(51, 25), Op::Call(193, vec![30, 45, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false), Op::Call(195, vec![14, 15, 16, 17, 52, 53, 54, 55], 4, false), Op::Mul(56, 10), Op::Const(G::from_u64(7)), Op::Mul(57, 11), Op::Mul(63, 64), Op::Add(62, 65), Op::Mul(56, 11), Op::Mul(57, 10), Op::Add(67, 68), Op::Add(58, 66), Op::Add(59, 69), Op::Mul(56, 12), Op::Mul(57, 13), Op::Mul(63, 73), Op::Add(72, 74), Op::Mul(56, 13), Op::Mul(57, 12), Op::Add(76, 77), Op::Add(60, 75), Op::Add(61, 78), Op::Call(195, vec![10, 11, 12, 13, 52, 53, 54, 55], 4, false), Op::Const(G::from_u64(1)), Op::Sub(85, 6), Op::Add(5, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(305, vec![35, 88], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 91), Op::Add(7, 92), Op::Call(305, vec![35, 93], 2, false), Op::Const(G::from_u64(0)), Op::Call(305, vec![36, 96], 2, false), Op::Add(97, 18), Op::Add(98, 19), Op::Call(305, vec![36, 91], 2, false), Op::Add(101, 20), Op::Add(102, 21), Op::Sub(99, 89), Op::Sub(100, 90), Op::Sub(103, 94), Op::Sub(104, 95), Op::Call(195, vec![81, 82, 83, 84, 105, 106, 107, 108], 4, false), Op::Sub(109, 70), Op::Sub(110, 71), Op::Call(190, vec![0, 1, 2, 3, 113, 114], 2, false), Op::Sub(111, 79), Op::Sub(112, 80), Op::Call(190, vec![115, 116, 2, 3, 117, 118], 2, false)], ctrl: Ctrl::Return(1, vec![119, 120]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(8, 88)], ctrl: Ctrl::Match(89, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(305, vec![35, 90], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 93), Op::Add(7, 94), Op::Call(305, vec![35, 95], 2, false), Op::Const(G::from_u64(2)), Op::Add(7, 98), Op::Add(7, 99), Op::Call(305, vec![35, 100], 2, false), Op::Const(G::from_u64(3)), Op::Add(7, 103), Op::Add(7, 104), Op::Call(305, vec![35, 105], 2, false), Op::Sub(101, 91), Op::Sub(102, 92), Op::Sub(106, 96), Op::Sub(107, 97), Op::Call(195, vec![81, 82, 83, 84, 108, 109, 110, 111], 4, false), Op::Sub(112, 70), Op::Sub(113, 71), Op::Call(190, vec![0, 1, 2, 3, 116, 117], 2, false), Op::Sub(114, 79), Op::Sub(115, 80), Op::Call(190, vec![118, 119, 2, 3, 120, 121], 2, false), Op::Add(5, 93), Op::Const(G::from_u64(0)), Op::Call(197, vec![122, 123, 2, 3, 47, 124, 6, 94, 9, 9, 93, 125, 125, 125, 125, 125, 125, 125, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(2, vec![126, 127]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 90), Op::Sub(8, 90), Op::Call(197, vec![0, 1, 2, 3, 47, 91, 6, 7, 92, 9, 81, 82, 83, 84, 70, 71, 79, 80, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(3, vec![93, 94]) }))) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 44, selectors: 4, auxiliaries: 46, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_198() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(194, vec![28, 28, 25, 26, 1, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false), Op::Sub(17, 15), Op::Sub(28, 28), Op::Mul(31, 27), Op::Const(G::from_u64(7)), Op::Mul(32, 28), Op::Mul(34, 35), Op::Add(33, 36), Op::Mul(31, 28), Op::Mul(32, 27), Op::Add(38, 39), Op::Mul(21, 37), Op::Mul(22, 40), Op::Mul(34, 42), Op::Add(41, 43), Op::Mul(21, 40), Op::Mul(22, 37), Op::Add(45, 46), Op::Sub(18, 16), Op::Mul(48, 27), Op::Add(49, 36), Op::Mul(48, 28), Op::Add(51, 39), Op::Mul(21, 50), Op::Mul(22, 52), Op::Mul(34, 54), Op::Add(53, 55), Op::Mul(21, 52), Op::Mul(22, 50), Op::Add(57, 58), Op::Load(4, 2)], ctrl: Ctrl::Match(60, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(305, vec![9, 64], 2, false), Op::Call(305, vec![8, 64], 2, false), Op::Sub(65, 67), Op::Sub(66, 68), Op::Add(69, 44), Op::Add(70, 47), Op::Call(190, vec![29, 30, 25, 26, 71, 72], 2, false), Op::Const(G::from_u64(1)), Op::Call(305, vec![9, 75], 2, false), Op::Call(305, vec![8, 75], 2, false), Op::Sub(76, 78), Op::Sub(77, 79), Op::Add(80, 56), Op::Add(81, 59), Op::Call(190, vec![73, 74, 25, 26, 82, 83], 2, false)], ctrl: Ctrl::Return(0, vec![84, 85]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(297, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::Call(197, vec![29, 30, 25, 26, 2, 64, 65, 64, 3, 3, 66, 64, 64, 64, 64, 64, 64, 64, 44, 47, 56, 59, 11, 28, 12, 28, 13, 28, 14, 28, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 28, selectors: 2, auxiliaries: 29, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_199() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![8, 7, 8, 10]), Op::Store(vec![8, 6, 8, 11]), Op::Store(vec![8, 5, 8, 12]), Op::Store(vec![8, 4, 8, 13]), Op::Store(vec![8, 3, 8, 14]), Op::Store(vec![8, 2, 8, 15]), Op::Store(vec![8, 1, 8, 16]), Op::Store(vec![8, 0, 8, 17])], ctrl: Ctrl::Return(0, vec![18]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 10, lookups: 10 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_200() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 9]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(3, 6), Op::Const(G::from_u64(7)), Op::Mul(4, 7), Op::Mul(10, 11), Op::Add(9, 12), Op::Mul(3, 7), Op::Mul(4, 6), Op::Add(14, 15), Op::Mul(3, 1), Op::Mul(4, 2), Op::Mul(10, 18), Op::Add(17, 19), Op::Mul(3, 2), Op::Mul(4, 1), Op::Add(21, 22), Op::Call(200, vec![8, 1, 2, 20, 23], 2, false), Op::Add(13, 24), Op::Add(16, 25)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_201() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(17, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Return(18, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 19, auxiliaries: 19, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_202() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(1, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![Op::Call(294, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(294, vec![4, 7], 1, false)], ctrl: Ctrl::Return(2, vec![6, 8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 4, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_203() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![31]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![2, 9], 1, false), Op::Const(G::from_u64(32)), Op::U8LessThan(31, 32), Op::Const(G::from_u64(1)), Op::AssertEq(vec![33], vec![34], None), Op::Call(201, vec![24], 1, false), Op::Call(305, vec![3, 9], 2, false), Op::Call(294, vec![4, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![38, 39], 1, false), Op::Call(294, vec![38, 34], 1, false), Op::Call(294, vec![5, 9], 1, false), Op::Call(294, vec![42, 39], 1, false), Op::Call(294, vec![42, 34], 1, false), Op::Call(305, vec![1, 9], 2, false)], ctrl: Ctrl::MatchContinue(45, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(1, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(2, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![Op::Call(294, vec![7, 46], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![47, 48], 1, false), Op::Const(G::from_u64(1)), Op::Call(294, vec![47, 50], 1, false)], ctrl: Ctrl::Yield(3, vec![49, 51]) })].into_iter().collect(), None) })].into_iter().collect(), None, 2, 3, 3, Box::new(Block { ops: vec![Op::Call(297, vec![40], 1, false), Op::Sub(49, 27), Op::EqZero(50), Op::Const(G::from_u64(1)), Op::AssertEq(vec![51], vec![52], None), Op::Call(297, vec![41], 1, false), Op::Sub(53, 27), Op::EqZero(54), Op::AssertEq(vec![55], vec![52], None), Op::Call(297, vec![43], 1, false), Op::Sub(56, 29), Op::EqZero(57), Op::AssertEq(vec![58], vec![52], None), Op::Call(297, vec![44], 1, false), Op::Sub(59, 29), Op::EqZero(60), Op::AssertEq(vec![61], vec![52], None), Op::Call(297, vec![47], 1, false), Op::Sub(62, 28), Op::EqZero(63), Op::AssertEq(vec![64], vec![52], None), Op::Call(297, vec![48], 1, false), Op::Sub(65, 28), Op::EqZero(66), Op::AssertEq(vec![67], vec![52], None), Op::Call(185, vec![18, 19, 31], 2, false), Op::Const(G::from_u64(0)), Op::Sub(68, 52), Op::Sub(69, 70), Op::Call(186, vec![31], 1, false), Op::UnconstrainedGInverse(73), Op::Mul(73, 74), Op::Sub(75, 52), Op::Mul(73, 76), Op::AssertEq(vec![77], vec![70], None), Op::Mul(74, 76), Op::AssertEq(vec![78], vec![70], None), Op::Sub(18, 52), Op::Sub(19, 70), Op::Mul(79, 79), Op::Const(G::from_u64(7)), Op::Mul(80, 80), Op::Mul(82, 83), Op::Sub(81, 84), Op::UnconstrainedGInverse(85), Op::Mul(85, 86), Op::Sub(87, 52), Op::Mul(85, 88), Op::AssertEq(vec![89], vec![70], None), Op::Mul(86, 88), Op::AssertEq(vec![90], vec![70], None), Op::Mul(79, 86), Op::Sub(70, 80), Op::Mul(92, 86), Op::Mul(71, 91), Op::Mul(72, 93), Op::Mul(82, 95), Op::Add(94, 96), Op::Mul(71, 93), Op::Mul(72, 91), Op::Add(98, 99), Op::Sub(18, 74), Op::Mul(101, 101), Op::Sub(102, 84), Op::UnconstrainedGInverse(103), Op::Mul(103, 104), Op::Sub(105, 52), Op::Mul(103, 106), Op::AssertEq(vec![107], vec![70], None), Op::Mul(104, 106), Op::AssertEq(vec![108], vec![70], None), Op::Mul(101, 104), Op::Mul(92, 104), Op::Mul(71, 109), Op::Mul(72, 110), Op::Mul(82, 112), Op::Add(111, 113), Op::Mul(71, 110), Op::Mul(72, 109), Op::Add(115, 116), Op::Mul(71, 71), Op::Mul(72, 72), Op::Mul(82, 119), Op::Sub(118, 120), Op::UnconstrainedGInverse(121), Op::Mul(121, 122), Op::Sub(123, 52), Op::Mul(121, 124), Op::AssertEq(vec![125], vec![70], None), Op::Mul(122, 124), Op::AssertEq(vec![126], vec![70], None), Op::Mul(71, 122), Op::Sub(70, 72), Op::Mul(128, 122), Op::Store(vec![52, 52, 52, 52]), Op::Store(vec![70, 37, 70, 130]), Op::Store(vec![70, 36, 70, 131]), Op::Store(vec![70, 11, 70, 132]), Op::Store(vec![70, 10, 70, 133]), Op::Store(vec![70, 15, 70, 134]), Op::Store(vec![70, 14, 70, 135]), Op::Store(vec![70, 13, 70, 136]), Op::Store(vec![70, 12, 70, 137]), Op::Call(188, vec![31], 1, false), Op::Call(186, vec![31], 1, false), Op::Mul(139, 140), Op::UnconstrainedGInverse(141), Op::Mul(141, 142), Op::Sub(143, 52), Op::Mul(141, 144), Op::AssertEq(vec![145], vec![70], None), Op::Mul(142, 144), Op::AssertEq(vec![146], vec![70], None), Op::Call(194, vec![70, 70, 16, 17, 23, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false), Op::Sub(36, 10), Op::Sub(70, 70), Op::Mul(149, 142), Op::Mul(150, 70), Op::Mul(82, 152), Op::Add(151, 153), Op::Mul(149, 70), Op::Mul(150, 142), Op::Add(155, 156), Op::Mul(114, 154), Op::Mul(117, 157), Op::Mul(82, 159), Op::Add(158, 160), Op::Mul(114, 157), Op::Mul(117, 154), Op::Add(162, 163), Op::Sub(37, 11), Op::Mul(165, 142), Op::Add(166, 153), Op::Mul(165, 70), Op::Add(168, 156), Op::Mul(114, 167), Op::Mul(117, 169), Op::Mul(82, 171), Op::Add(170, 172), Op::Mul(114, 169), Op::Mul(117, 167), Op::Add(174, 175), Op::Load(4, 25)], ctrl: Ctrl::MatchContinue(177, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(305, vec![44, 181], 2, false), Op::Call(305, vec![43, 181], 2, false), Op::Sub(182, 184), Op::Sub(183, 185), Op::Add(186, 161), Op::Add(187, 164), Op::Call(190, vec![147, 148, 16, 17, 188, 189], 2, false), Op::Const(G::from_u64(1)), Op::Call(305, vec![44, 192], 2, false), Op::Call(305, vec![43, 192], 2, false), Op::Sub(193, 195), Op::Sub(194, 196), Op::Add(197, 173), Op::Add(198, 176), Op::Call(190, vec![190, 191, 16, 17, 199, 200], 2, false)], ctrl: Ctrl::Yield(4, vec![201, 202]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(297, vec![25], 1, false), Op::Const(G::from_u64(1)), Op::Call(197, vec![147, 148, 16, 17, 25, 181, 182, 181, 26, 26, 183, 181, 181, 181, 181, 181, 181, 181, 161, 164, 173, 176, 12, 70, 13, 70, 14, 70, 15, 70, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false)], ctrl: Ctrl::Yield(5, vec![184, 185]) })].into_iter().collect(), None, 2, 12, 6, Box::new(Block { ops: vec![Op::Call(294, vec![8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![183, 184], 1, false), Op::Call(192, vec![185], 1, false), Op::Call(297, vec![186], 1, false), Op::Sub(187, 35), Op::EqZero(188), Op::Const(G::from_u64(1)), Op::AssertEq(vec![189], vec![190], None), Op::Call(185, vec![18, 19, 31], 2, false), Op::Call(200, vec![186, 191, 192, 190, 184], 2, false), Op::Mul(181, 127), Op::Const(G::from_u64(7)), Op::Mul(182, 129), Op::Mul(196, 197), Op::Add(195, 198), Op::Mul(181, 129), Op::Mul(182, 127), Op::Add(200, 201), Op::Sub(199, 193), Op::EqZero(203), Op::Sub(202, 194), Op::EqZero(205), Op::Mul(204, 206), Op::AssertEq(vec![207], vec![190], None), Op::Add(9, 190), Op::Call(203, vec![30, 1, 2, 3, 4, 5, 6, 7, 8, 208, 36, 37, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Return(6, vec![209]) })) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 20, selectors: 7, auxiliaries: 152, lookups: 50 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_204() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![13, 13]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(13, 5), Op::Const(G::from_u64(65536)), Op::Mul(15, 6), Op::Const(G::from_u64(16777216)), Op::Mul(17, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 11), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(4, 32), Op::Const(G::from_u64(0)), Op::Call(204, vec![0, 1, 12], 2, false), Op::Mul(0, 35), Op::Const(G::from_u64(7)), Op::Mul(1, 36), Op::Mul(38, 39), Op::Add(37, 40), Op::Mul(0, 36), Op::Mul(1, 35), Op::Add(42, 43), Op::Add(33, 41), Op::Add(34, 44)], ctrl: Ctrl::Return(1, vec![45, 46]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 17, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_205() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(204, vec![5, 6, 8], 2, false), Op::Add(3, 10), Op::Add(4, 11), Op::Mul(12, 12), Op::Const(G::from_u64(7)), Op::Mul(13, 13), Op::Mul(15, 16), Op::Sub(14, 17), Op::UnconstrainedGInverse(18), Op::Mul(18, 19), Op::Const(G::from_u64(1)), Op::Sub(20, 21), Op::Mul(18, 22), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None), Op::Mul(19, 22), Op::AssertEq(vec![25], vec![24], None), Op::Mul(12, 19), Op::Sub(24, 13), Op::Mul(27, 19), Op::Add(0, 26), Op::Add(1, 28), Op::Call(205, vec![29, 30, 9, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![31, 32]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_206() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 4), Op::Mul(2, 5), Op::Const(G::from_u64(0)), Op::AssertEq(vec![6], vec![7], None), Op::Call(206, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_207() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Call(207, vec![12, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(207, vec![12, 15], 1, false), Op::Store(vec![16, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17])], ctrl: Ctrl::Return(2, vec![18]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_208() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(208, vec![5, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(208, vec![5, 8], 1, false), Op::Store(vec![9, 3, 4, 10])], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_209() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(2, 3), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::Const(G::from_u64(256)), Op::Mul(10, 3), Op::Const(G::from_u64(65536)), Op::Mul(12, 4), Op::Const(G::from_u64(16777216)), Op::Mul(14, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 9), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(2, 29), Op::AssertEq(vec![30], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(9, 31), Op::Add(8, 32), Op::Add(7, 33), Op::Add(6, 34), Op::EqZero(35), Op::Add(4, 5), Op::Add(3, 37), Op::Add(2, 38), Op::EqZero(39), Op::Const(G::from_u64(1)), Op::Sub(41, 40), Op::Mul(36, 42), Op::Sub(41, 43), Op::AssertEq(vec![44], vec![41], None), Op::Call(171, vec![2, 3, 4, 5, 6, 7, 8, 9, 1], 1, false)], ctrl: Ctrl::Return(0, vec![45]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_210() -> Function { + Function { body: Block { ops: vec![Op::Call(296, vec![0], 1, false), Op::Call(211, vec![0, 1], 1, false), Op::Call(209, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_211() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(301, vec![3], 1, false), Op::Call(211, vec![4, 1], 1, false), Op::Call(183, vec![3, 6], 1, false), Op::Call(209, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_212() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![2], 1, false), Op::Call(210, vec![3, 4], 1, false), Op::Call(174, vec![2, 6], 1, false), Op::Call(209, vec![5, 7], 1, false), Op::Call(173, vec![1, 8], 1, false), Op::Call(174, vec![0, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_213() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(213, vec![7, 1], 1, false), Op::Call(212, vec![3, 4, 5, 6, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_214() -> Function { + Function { body: Block { ops: vec![Op::Call(302, vec![0], 1, false), Op::Call(215, vec![0, 1], 1, false), Op::Call(209, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_215() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![3], 1, false), Op::Call(215, vec![12, 1], 1, false), Op::Call(171, vec![4, 5, 6, 7, 8, 9, 10, 11, 14], 1, false), Op::Call(183, vec![3, 15], 1, false), Op::Call(209, vec![13, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_216() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(214, vec![3, 5], 1, false), Op::Call(213, vec![2, 6], 1, false), Op::Call(299, vec![2], 1, false), Op::Call(209, vec![8, 7], 1, false), Op::Call(173, vec![1, 9], 1, false), Op::Call(183, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![12, 25, 11]), Op::Store(vec![12, 24, 26]), Op::Store(vec![12, 23, 27]), Op::Store(vec![12, 22, 28]), Op::Store(vec![12, 21, 29]), Op::Store(vec![12, 20, 30]), Op::Store(vec![12, 16, 31]), Op::Store(vec![12, 19, 32]), Op::Store(vec![12, 18, 33]), Op::Store(vec![12, 17, 34]), Op::Store(vec![12, 16, 35]), Op::Store(vec![12, 15, 36]), Op::Store(vec![12, 14, 37]), Op::Store(vec![12, 13, 38]), Op::Call(177, vec![39, 5], 18, false), Op::Call(171, vec![48, 49, 50, 51, 52, 53, 54, 55, 5], 1, false), Op::Call(171, vec![40, 41, 42, 43, 44, 45, 46, 47, 58], 1, false), Op::Call(298, vec![56, 59], 1, false), Op::Call(177, vec![60, 5], 18, false), Op::Call(171, vec![69, 70, 71, 72, 73, 74, 75, 76, 5], 1, false), Op::Call(171, vec![61, 62, 63, 64, 65, 66, 67, 68, 79], 1, false), Op::Call(298, vec![77, 80], 1, false), Op::Const(G::from_u64(256)), Op::Mul(82, 41), Op::Const(G::from_u64(65536)), Op::Mul(84, 42), Op::Const(G::from_u64(16777216)), Op::Mul(86, 43), Op::Const(G::from_u64(4294967296)), Op::Mul(88, 44), Op::Const(G::from_u64(1099511627776)), Op::Mul(90, 45), Op::Const(G::from_u64(281474976710656)), Op::Mul(92, 46), Op::Const(G::from_u64(72057594037927936)), Op::Mul(94, 47), Op::Add(93, 95), Op::Add(91, 96), Op::Add(89, 97), Op::Add(87, 98), Op::Add(85, 99), Op::Add(83, 100), Op::Add(40, 101), Op::Mul(82, 49), Op::Mul(84, 50), Op::Mul(86, 51), Op::Mul(88, 52), Op::Mul(90, 53), Op::Mul(92, 54), Op::Mul(94, 55), Op::Add(108, 109), Op::Add(107, 110), Op::Add(106, 111), Op::Add(105, 112), Op::Add(104, 113), Op::Add(103, 114), Op::Add(48, 115), Op::Mul(82, 62), Op::Mul(84, 63), Op::Mul(86, 64), Op::Mul(88, 65), Op::Mul(90, 66), Op::Mul(92, 67), Op::Mul(94, 68), Op::Add(122, 123), Op::Add(121, 124), Op::Add(120, 125), Op::Add(119, 126), Op::Add(118, 127), Op::Add(117, 128), Op::Add(61, 129), Op::Mul(82, 70), Op::Mul(84, 71), Op::Mul(86, 72), Op::Mul(88, 73), Op::Mul(90, 74), Op::Mul(92, 75), Op::Mul(94, 76), Op::Add(136, 137), Op::Add(135, 138), Op::Add(134, 139), Op::Add(133, 140), Op::Add(132, 141), Op::Add(131, 142), Op::Add(69, 143)], ctrl: Ctrl::Return(0, vec![102, 116, 130, 144, 81]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_217() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::U8RangeCheck(11, 12), Op::Const(G::from_u64(256)), Op::Mul(13, 6), Op::Const(G::from_u64(65536)), Op::Mul(15, 7), Op::Const(G::from_u64(16777216)), Op::Mul(17, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 12), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(5, 32), Op::AssertEq(vec![33], vec![1], None), Op::Const(G::from_u64(1020)), Op::Sub(12, 34), Op::Add(11, 35), Op::Add(10, 36), Op::Add(9, 37), Op::EqZero(38), Op::Add(7, 8), Op::Add(6, 40), Op::Add(5, 41), Op::EqZero(42), Op::Const(G::from_u64(1)), Op::Sub(44, 43), Op::Mul(39, 45), Op::Sub(44, 46), Op::AssertEq(vec![47], vec![44], None), Op::Call(180, vec![0, 5, 6, 7, 8, 9, 10, 11, 12], 1, false), Op::Call(181, vec![48, 2], 1, false), Op::Store(vec![44, 44, 44]), Op::Call(134, vec![4, 50], 1, false), Op::Call(298, vec![49, 51], 1, false), Op::Call(177, vec![52, 50], 18, false), Op::Call(181, vec![69, 3], 1, false), Op::Call(177, vec![71, 50], 18, false), Op::Mul(13, 54), Op::Mul(15, 55), Op::Mul(17, 56), Op::Mul(19, 57), Op::Mul(21, 58), Op::Mul(23, 59), Op::Mul(25, 60), Op::Add(95, 96), Op::Add(94, 97), Op::Add(93, 98), Op::Add(92, 99), Op::Add(91, 100), Op::Add(90, 101), Op::Add(53, 102), Op::Mul(13, 62), Op::Mul(15, 63), Op::Mul(17, 64), Op::Mul(19, 65), Op::Mul(21, 66), Op::Mul(23, 67), Op::Mul(25, 68), Op::Add(109, 110), Op::Add(108, 111), Op::Add(107, 112), Op::Add(106, 113), Op::Add(105, 114), Op::Add(104, 115), Op::Add(61, 116), Op::Mul(13, 73), Op::Mul(15, 74), Op::Mul(17, 75), Op::Mul(19, 76), Op::Mul(21, 77), Op::Mul(23, 78), Op::Mul(25, 79), Op::Add(123, 124), Op::Add(122, 125), Op::Add(121, 126), Op::Add(120, 127), Op::Add(119, 128), Op::Add(118, 129), Op::Add(72, 130), Op::Mul(13, 81), Op::Mul(15, 82), Op::Mul(17, 83), Op::Mul(19, 84), Op::Mul(21, 85), Op::Mul(23, 86), Op::Mul(25, 87), Op::Add(137, 138), Op::Add(136, 139), Op::Add(135, 140), Op::Add(134, 141), Op::Add(133, 142), Op::Add(132, 143), Op::Add(80, 144)], ctrl: Ctrl::Return(0, vec![103, 117, 131, 145, 88]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_218() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![3], vec![6], None), Op::Call(218, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_219() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21], vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22], None)], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(12, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![22], vec![23], None), Op::Call(219, vec![11, 21], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_220() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(219, vec![3, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], None), Op::Call(220, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_221() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Load(32, 6), Op::Call(12, vec![8, 9, 10, 11, 12, 13, 14, 15, 40, 41, 42, 43, 44, 45, 46, 47], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![72], vec![73], None), Op::Call(12, vec![16, 17, 18, 19, 20, 21, 22, 23, 48, 49, 50, 51, 52, 53, 54, 55], 1, false), Op::AssertEq(vec![74], vec![73], None), Op::Call(12, vec![24, 25, 26, 27, 28, 29, 30, 31, 56, 57, 58, 59, 60, 61, 62, 63], 1, false), Op::AssertEq(vec![75], vec![73], None), Op::Call(12, vec![32, 33, 34, 35, 36, 37, 38, 39, 64, 65, 66, 67, 68, 69, 70, 71], 1, false), Op::AssertEq(vec![76], vec![73], None), Op::Call(221, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![77]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_222() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(222, vec![4], 2, false)], ctrl: Ctrl::Return(1, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_223() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(204, vec![5, 6, 8], 2, false), Op::Add(3, 18), Op::Add(4, 19), Op::Mul(20, 20), Op::Const(G::from_u64(7)), Op::Mul(21, 21), Op::Mul(23, 24), Op::Sub(22, 25), Op::UnconstrainedGInverse(26), Op::Mul(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Mul(26, 30), Op::Const(G::from_u64(0)), Op::AssertEq(vec![31], vec![32], None), Op::Mul(27, 30), Op::AssertEq(vec![33], vec![32], None), Op::Mul(20, 27), Op::Sub(32, 21), Op::Mul(35, 27), Op::Const(G::from_u64(256)), Op::Mul(37, 10), Op::Const(G::from_u64(65536)), Op::Mul(39, 11), Op::Const(G::from_u64(16777216)), Op::Mul(41, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(43, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(45, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(47, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(49, 16), Op::Add(48, 50), Op::Add(46, 51), Op::Add(44, 52), Op::Add(42, 53), Op::Add(40, 54), Op::Add(38, 55), Op::Add(9, 56), Op::Mul(34, 57), Op::Mul(36, 32), Op::Mul(23, 59), Op::Add(58, 60), Op::Mul(34, 32), Op::Mul(36, 57), Op::Add(62, 63), Op::Add(0, 61), Op::Add(1, 64), Op::Call(223, vec![65, 66, 17, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_224() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(26, vec![1]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(27, vec![1]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(28, vec![1]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(29, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(30, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(31, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(32, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(33, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_225() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(224, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], None), Op::Call(225, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_226() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(226, vec![3], 1, false), Op::Add(2, 4)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_227() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![2], None), Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::Const(G::from_u64(256)), Op::Mul(11, 4), Op::Const(G::from_u64(65536)), Op::Mul(13, 5), Op::Const(G::from_u64(16777216)), Op::Mul(15, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(17, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(19, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(21, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(23, 10), Op::Add(22, 24), Op::Add(20, 25), Op::Add(18, 26), Op::Add(16, 27), Op::Add(14, 28), Op::Add(12, 29), Op::Add(3, 30), Op::AssertEq(vec![31], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(10, 32), Op::Add(9, 33), Op::Add(8, 34), Op::Add(7, 35), Op::EqZero(36), Op::Add(5, 6), Op::Add(4, 38), Op::Add(3, 39), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::Sub(42, 41), Op::Mul(37, 43), Op::Sub(42, 44), Op::AssertEq(vec![45], vec![42], None), Op::Add(9, 10), Op::Add(8, 46), Op::Add(7, 47), Op::Add(6, 48), Op::AssertEq(vec![49], vec![2], None), Op::Sub(5, 42), Op::Mul(5, 50), Op::AssertEq(vec![51], vec![2], None), Op::Add(3, 4), Op::Mul(5, 52), Op::AssertEq(vec![53], vec![2], None)], ctrl: Ctrl::Return(0, vec![42]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_228() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 20)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 30), Op::Const(G::from_u64(1)), Op::AssertEq(vec![31, 32, 33, 34, 35, 36, 37, 38, 39, 40], vec![41, 41, 41, 41, 41, 41, 41, 41, 41, 41], None)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 27, 28, 29]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_229() -> Function { + Function { body: Block { ops: vec![Op::U8LessThan(0, 1), Op::Sub(0, 1), Op::EqZero(4), Op::Mul(5, 2), Op::Add(3, 6)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_230() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(229, vec![0, 8, 16], 1, false), Op::Call(229, vec![1, 9, 17], 1, false), Op::Call(229, vec![2, 10, 18], 1, false), Op::Call(229, vec![3, 11, 19], 1, false), Op::Call(229, vec![4, 12, 20], 1, false), Op::Call(229, vec![5, 13, 21], 1, false), Op::Call(229, vec![6, 14, 22], 1, false), Op::Call(229, vec![7, 15, 23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_231() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(11, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(25, 6), Op::Const(G::from_u64(65536)), Op::Mul(27, 7), Op::Const(G::from_u64(16777216)), Op::Mul(29, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(31, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(33, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(35, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(37, 12), Op::Add(36, 38), Op::Add(34, 39), Op::Add(32, 40), Op::Add(30, 41), Op::Add(28, 42), Op::Add(26, 43), Op::Add(5, 44), Op::Const(G::from_u64(1)), Op::Add(45, 46), Op::Const(G::from_u64(0)), Op::AssertEq(vec![47], vec![48], None), Op::Mul(25, 17), Op::Mul(27, 18), Op::Mul(29, 19), Op::Mul(31, 20), Op::Mul(33, 21), Op::Mul(35, 22), Op::Mul(37, 23), Op::Add(54, 55), Op::Add(53, 56), Op::Add(52, 57), Op::Add(51, 58), Op::Add(50, 59), Op::Add(49, 60), Op::Add(16, 61), Op::AssertEq(vec![62], vec![46], None), Op::Call(228, vec![4], 24, false), Op::Call(228, vec![15], 24, false), Op::Mul(25, 64), Op::Mul(27, 65), Op::Mul(29, 66), Op::Mul(31, 67), Op::Mul(33, 68), Op::Mul(35, 69), Op::Mul(37, 70), Op::Add(116, 117), Op::Add(115, 118), Op::Add(114, 119), Op::Add(113, 120), Op::Add(112, 121), Op::Add(111, 122), Op::Add(63, 123), Op::Const(G::from_u64(16)), Op::AssertEq(vec![124], vec![125], None), Op::Mul(25, 88), Op::Mul(27, 89), Op::Mul(29, 90), Op::Mul(31, 91), Op::Mul(33, 92), Op::Mul(35, 93), Op::Mul(37, 94), Op::Add(131, 132), Op::Add(130, 133), Op::Add(129, 134), Op::Add(128, 135), Op::Add(127, 136), Op::Add(126, 137), Op::Add(87, 138), Op::AssertEq(vec![139], vec![125], None), Op::Mul(25, 72), Op::Mul(27, 73), Op::Mul(29, 74), Op::Mul(31, 75), Op::Mul(33, 76), Op::Mul(35, 77), Op::Mul(37, 78), Op::Add(145, 146), Op::Add(144, 147), Op::Add(143, 148), Op::Add(142, 149), Op::Add(141, 150), Op::Add(140, 151), Op::Add(71, 152), Op::Mul(25, 96), Op::Mul(27, 97), Op::Mul(29, 98), Op::Mul(31, 99), Op::Mul(33, 100), Op::Mul(35, 101), Op::Mul(37, 102), Op::Add(159, 160), Op::Add(158, 161), Op::Add(157, 162), Op::Add(156, 163), Op::Add(155, 164), Op::Add(154, 165), Op::Add(95, 166), Op::AssertEq(vec![167], vec![153], None), Op::Mul(25, 80), Op::Mul(27, 81), Op::Mul(29, 82), Op::Mul(31, 83), Op::Mul(33, 84), Op::Mul(35, 85), Op::Mul(37, 86), Op::Add(173, 174), Op::Add(172, 175), Op::Add(171, 176), Op::Add(170, 177), Op::Add(169, 178), Op::Add(168, 179), Op::Add(79, 180), Op::Mul(25, 104), Op::Mul(27, 105), Op::Mul(29, 106), Op::Mul(31, 107), Op::Mul(33, 108), Op::Mul(35, 109), Op::Mul(37, 110), Op::Add(187, 188), Op::Add(186, 189), Op::Add(185, 190), Op::Add(184, 191), Op::Add(183, 192), Op::Add(182, 193), Op::Add(103, 194), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(196, 197), Op::U8RangeCheck(198, 199), Op::U8RangeCheck(200, 201), Op::U8RangeCheck(202, 203), Op::Mul(25, 197), Op::Mul(27, 198), Op::Mul(29, 199), Op::Mul(31, 200), Op::Mul(33, 201), Op::Mul(35, 202), Op::Mul(37, 203), Op::Add(209, 210), Op::Add(208, 211), Op::Add(207, 212), Op::Add(206, 213), Op::Add(205, 214), Op::Add(204, 215), Op::Add(196, 216), Op::AssertEq(vec![217], vec![181], None), Op::Const(G::from_u64(1020)), Op::Sub(203, 218), Op::Add(202, 219), Op::Add(201, 220), Op::Add(200, 221), Op::EqZero(222), Op::Add(198, 199), Op::Add(197, 224), Op::Add(196, 225), Op::EqZero(226), Op::Sub(46, 227), Op::Mul(223, 228), Op::Sub(46, 229), Op::AssertEq(vec![230], vec![46], None), Op::UnconstrainedGToBytes(195), Op::U8RangeCheck(231, 232), Op::U8RangeCheck(233, 234), Op::U8RangeCheck(235, 236), Op::U8RangeCheck(237, 238), Op::Mul(25, 232), Op::Mul(27, 233), Op::Mul(29, 234), Op::Mul(31, 235), Op::Mul(33, 236), Op::Mul(35, 237), Op::Mul(37, 238), Op::Add(244, 245), Op::Add(243, 246), Op::Add(242, 247), Op::Add(241, 248), Op::Add(240, 249), Op::Add(239, 250), Op::Add(231, 251), Op::AssertEq(vec![252], vec![195], None), Op::Sub(238, 218), Op::Add(237, 253), Op::Add(236, 254), Op::Add(235, 255), Op::EqZero(256), Op::Add(233, 234), Op::Add(232, 258), Op::Add(231, 259), Op::EqZero(260), Op::Sub(46, 261), Op::Mul(257, 262), Op::Sub(46, 263), Op::AssertEq(vec![264], vec![46], None), Op::Call(230, vec![196, 197, 198, 199, 200, 201, 202, 203, 231, 232, 233, 234, 235, 236, 237, 238], 1, false), Op::AssertEq(vec![265], vec![46], None), Op::Sub(153, 1), Op::EqZero(266), Op::UnconstrainedGToBytes(153), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::U8RangeCheck(272, 273), Op::U8RangeCheck(274, 275), Op::Mul(25, 269), Op::Mul(27, 270), Op::Mul(29, 271), Op::Mul(31, 272), Op::Mul(33, 273), Op::Mul(35, 274), Op::Mul(37, 275), Op::Add(281, 282), Op::Add(280, 283), Op::Add(279, 284), Op::Add(278, 285), Op::Add(277, 286), Op::Add(276, 287), Op::Add(268, 288), Op::AssertEq(vec![289], vec![153], None), Op::Sub(275, 218), Op::Add(274, 290), Op::Add(273, 291), Op::Add(272, 292), Op::EqZero(293), Op::Add(270, 271), Op::Add(269, 295), Op::Add(268, 296), Op::EqZero(297), Op::Sub(46, 298), Op::Mul(294, 299), Op::Sub(46, 300), Op::AssertEq(vec![301], vec![46], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(302, 303), Op::U8RangeCheck(304, 305), Op::U8RangeCheck(306, 307), Op::U8RangeCheck(308, 309), Op::Mul(25, 303), Op::Mul(27, 304), Op::Mul(29, 305), Op::Mul(31, 306), Op::Mul(33, 307), Op::Mul(35, 308), Op::Mul(37, 309), Op::Add(315, 316), Op::Add(314, 317), Op::Add(313, 318), Op::Add(312, 319), Op::Add(311, 320), Op::Add(310, 321), Op::Add(302, 322), Op::AssertEq(vec![323], vec![1], None), Op::Sub(309, 218), Op::Add(308, 324), Op::Add(307, 325), Op::Add(306, 326), Op::EqZero(327), Op::Add(304, 305), Op::Add(303, 329), Op::Add(302, 330), Op::EqZero(331), Op::Sub(46, 332), Op::Mul(328, 333), Op::Sub(46, 334), Op::AssertEq(vec![335], vec![46], None), Op::Call(230, vec![268, 269, 270, 271, 272, 273, 274, 275, 302, 303, 304, 305, 306, 307, 308, 309], 1, false), Op::Sub(46, 336), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(338, 339), Op::U8RangeCheck(340, 341), Op::U8RangeCheck(342, 343), Op::U8RangeCheck(344, 345), Op::Mul(25, 339), Op::Mul(27, 340), Op::Mul(29, 341), Op::Mul(31, 342), Op::Mul(33, 343), Op::Mul(35, 344), Op::Mul(37, 345), Op::Add(351, 352), Op::Add(350, 353), Op::Add(349, 354), Op::Add(348, 355), Op::Add(347, 356), Op::Add(346, 357), Op::Add(338, 358), Op::AssertEq(vec![359], vec![2], None), Op::Sub(345, 218), Op::Add(344, 360), Op::Add(343, 361), Op::Add(342, 362), Op::EqZero(363), Op::Add(340, 341), Op::Add(339, 365), Op::Add(338, 366), Op::EqZero(367), Op::Sub(46, 368), Op::Mul(364, 369), Op::Sub(46, 370), Op::AssertEq(vec![371], vec![46], None), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(372, 373), Op::U8RangeCheck(374, 375), Op::U8RangeCheck(376, 377), Op::U8RangeCheck(378, 379), Op::Mul(25, 373), Op::Mul(27, 374), Op::Mul(29, 375), Op::Mul(31, 376), Op::Mul(33, 377), Op::Mul(35, 378), Op::Mul(37, 379), Op::Add(385, 386), Op::Add(384, 387), Op::Add(383, 388), Op::Add(382, 389), Op::Add(381, 390), Op::Add(380, 391), Op::Add(372, 392), Op::AssertEq(vec![393], vec![181], None), Op::Sub(379, 218), Op::Add(378, 394), Op::Add(377, 395), Op::Add(376, 396), Op::EqZero(397), Op::Add(374, 375), Op::Add(373, 399), Op::Add(372, 400), Op::EqZero(401), Op::Sub(46, 402), Op::Mul(398, 403), Op::Sub(46, 404), Op::AssertEq(vec![405], vec![46], None), Op::Call(230, vec![338, 339, 340, 341, 342, 343, 344, 345, 372, 373, 374, 375, 376, 377, 378, 379], 1, false), Op::Mul(267, 406), Op::Add(337, 407), Op::AssertEq(vec![408], vec![46], None), Op::Call(231, vec![24, 153, 195], 1, false)], ctrl: Ctrl::Return(1, vec![409]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_232() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![46], None), Op::AssertEq(vec![2], vec![46], None), Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![47], None)], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(17, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(297, vec![21], 1, false), Op::EqZero(48), Op::Const(G::from_u64(0)), Op::AssertEq(vec![49], vec![50], None), Op::Call(296, vec![39], 1, false), Op::AssertEq(vec![51], vec![48], None), Op::Call(296, vec![40], 1, false), Op::AssertEq(vec![52], vec![48], None), Op::Call(296, vec![36], 1, false), Op::AssertEq(vec![53], vec![48], None), Op::Call(206, vec![17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![54], vec![55], None), Op::Call(296, vec![17], 1, false), Op::Call(302, vec![8], 1, false), Op::Sub(56, 57), Op::EqZero(58), Op::AssertEq(vec![59], vec![55], None), Op::Call(207, vec![8, 17], 1, false), Op::Call(208, vec![11, 17], 1, false), Op::Call(302, vec![60], 1, false), Op::Call(297, vec![21], 1, false), Op::Sub(62, 63), Op::EqZero(64), Op::AssertEq(vec![65], vec![55], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![12, 17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![66], vec![67], None), Op::Call(221, vec![13, 18], 1, false), Op::AssertEq(vec![68], vec![67], None), Op::Call(218, vec![14, 22], 1, false), Op::AssertEq(vec![69], vec![67], None), Op::Call(225, vec![22], 1, false), Op::AssertEq(vec![70], vec![67], None), Op::Call(226, vec![17], 1, false), Op::Call(296, vec![22], 1, false), Op::AssertEq(vec![71], vec![72], None)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![73, 73, 73])], ctrl: Ctrl::Yield(0, vec![74]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(217, vec![41, 16, 19, 20, 21], 5, false), Op::Const(G::from_u64(0)), Op::Call(205, vec![79, 79, 15, 42, 43, 44, 45], 2, false), Op::Call(203, vec![60, 61, 22, 21, 39, 40, 37, 38, 36, 79, 80, 81, 42, 43, 44, 45, 74, 75, 76, 77], 1, false), Op::Call(302, vec![60], 1, false)], ctrl: Ctrl::Match(23, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![23], 1, false), Op::Call(301, vec![24], 1, false), Op::Sub(85, 84), Op::EqZero(86), Op::Const(G::from_u64(1)), Op::AssertEq(vec![87], vec![88], None), Op::Call(297, vec![25], 1, false), Op::Const(G::from_u64(3)), Op::Call(145, vec![37, 38], 1, false), Op::Add(90, 91), Op::AssertEq(vec![89], vec![92], None), Op::Call(307, vec![26], 1, false), Op::Sub(93, 84), Op::EqZero(94), Op::AssertEq(vec![95], vec![88], None), Op::Call(297, vec![27], 1, false), Op::AssertEq(vec![96], vec![88], None), Op::Store(vec![88, 88, 88])], ctrl: Ctrl::MatchContinue(37, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![97]) }), (G::from_u64(1), Block { ops: vec![Op::Call(136, vec![38, 97], 1, false)], ctrl: Ctrl::Yield(3, vec![98]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(136, vec![36, 98], 1, false), Op::Call(136, vec![40, 99], 1, false), Op::Call(136, vec![39, 100], 1, false), Op::Call(298, vec![78, 101], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![103, 103, 103]), Op::Call(177, vec![102, 104], 18, false), Op::Const(G::from_u64(256)), Op::Mul(123, 106), Op::Const(G::from_u64(65536)), Op::Mul(125, 107), Op::Const(G::from_u64(16777216)), Op::Mul(127, 108), Op::Const(G::from_u64(4294967296)), Op::Mul(129, 109), Op::Const(G::from_u64(1099511627776)), Op::Mul(131, 110), Op::Const(G::from_u64(281474976710656)), Op::Mul(133, 111), Op::Const(G::from_u64(72057594037927936)), Op::Mul(135, 112), Op::Add(134, 136), Op::Add(132, 137), Op::Add(130, 138), Op::Add(128, 139), Op::Add(126, 140), Op::Add(124, 141), Op::Add(105, 142), Op::Mul(123, 114), Op::Mul(125, 115), Op::Mul(127, 116), Op::Mul(129, 117), Op::Mul(131, 118), Op::Mul(133, 119), Op::Mul(135, 120), Op::Add(149, 150), Op::Add(148, 151), Op::Add(147, 152), Op::Add(146, 153), Op::Add(145, 154), Op::Add(144, 155), Op::Add(113, 156), Op::Call(140, vec![121, 23, 24, 5], 2, false), Op::Call(134, vec![27, 104], 1, false), Op::Call(298, vec![159, 160], 1, false), Op::Call(138, vec![161, 23], 1, false), Op::Call(139, vec![162, 28, 29, 30, 31, 32, 33, 34, 35, 6], 2, false), Op::Add(84, 0), Op::Const(G::from_u64(33)), Op::U32LessThan(165, 166), Op::AssertEq(vec![167], vec![103], None), Op::Call(161, vec![163, 164, 4, 165], 1, false), Op::Call(165, vec![25, 168, 18, 19, 20, 73, 37, 38, 61, 22, 83, 0, 165], 1, false), Op::AssertEq(vec![169], vec![103], None), Op::Const(G::from_u64(0)), Op::Call(164, vec![25, 26, 170, 4], 1, false), Op::Call(160, vec![163, 164, 171, 143, 157, 39, 40, 36, 37, 38, 18, 19, 20, 73, 61, 22, 76, 77, 83, 0, 165, 158, 23, 27, 84], 1, false), Op::Call(168, vec![26, 23, 172, 168, 170, 165], 1, false), Op::AssertEq(vec![173], vec![103], None), Op::Call(222, vec![21], 2, false)], ctrl: Ctrl::Return(4, vec![174, 175]) })) }))) })) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_233() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Load(26, 13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53], vec![54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54], None)], ctrl: Ctrl::Return(0, vec![20, 21]) }), (G::from_u64(0), Block { ops: vec![Op::Load(26, 13)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Call(232, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 23, 24, 25, 26, 14, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(1)), Op::Add(14, 56), Op::Add(20, 54), Op::Add(21, 55), Op::Call(233, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 27, 53, 57, 15, 16, 17, 18, 19, 58, 59], 2, false)], ctrl: Ctrl::Return(1, vec![60, 61]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_234() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(234, vec![6], 1, false), Op::Call(298, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_235() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(299, vec![12], 1, false), Op::Call(227, vec![15], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None), Op::Call(295, vec![14], 1, false), Op::Call(299, vec![12], 1, false), Op::AssertEq(vec![18], vec![19], None), Op::Const(G::from_u64(0)), Op::Call(231, vec![13, 20, 20], 1, false), Op::AssertEq(vec![21], vec![17], None)], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22])], ctrl: Ctrl::Yield(0, vec![23]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(216, vec![7, 22, 12, 13], 5, false), Op::Const(G::from_u64(0)), Op::Call(223, vec![28, 28, 13, 23, 24, 25, 26], 2, false), Op::Call(233, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 28, 27, 23, 24, 25, 26, 29, 30], 2, false), Op::EqZero(31), Op::EqZero(32), Op::Mul(33, 34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(234, vec![12], 1, false)], ctrl: Ctrl::Return(2, vec![37]) })) }))) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_236() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![12], 2, false), Op::Call(65, vec![16, 15], 2, false), Op::Call(31, vec![18], 2, false), Op::Call(68, vec![20, 19], 2, false), Op::Call(31, vec![22], 2, false), Op::Call(70, vec![24, 23], 2, false), Op::Add(12, 13), Op::AssertEq(vec![26], vec![27], None), Op::Call(235, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 21, 25], 1, false), Op::Call(220, vec![28, 14], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![29], vec![30], None)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 15, selectors: 1, auxiliaries: 15, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_237() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(238, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_238() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(240, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(238, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_239() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(240, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_240() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(27, vec![0], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(240, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_241() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Store(vec![2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 86, 89, 92, 95])], ctrl: Ctrl::Return(0, vec![97, 96]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 98, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_242() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(0)), Op::Store(vec![34, 33, 1]), Op::Store(vec![34, 32, 35]), Op::Store(vec![34, 31, 36]), Op::Store(vec![34, 30, 37]), Op::Store(vec![34, 29, 38]), Op::Store(vec![34, 28, 39]), Op::Store(vec![34, 27, 40]), Op::Store(vec![34, 26, 41]), Op::Store(vec![34, 25, 42]), Op::Store(vec![34, 24, 43]), Op::Store(vec![34, 23, 44]), Op::Store(vec![34, 22, 45]), Op::Store(vec![34, 21, 46]), Op::Store(vec![34, 20, 47]), Op::Store(vec![34, 19, 48]), Op::Store(vec![34, 18, 49]), Op::Store(vec![34, 17, 50]), Op::Store(vec![34, 16, 51]), Op::Store(vec![34, 15, 52]), Op::Store(vec![34, 14, 53]), Op::Store(vec![34, 13, 54]), Op::Store(vec![34, 12, 55]), Op::Store(vec![34, 11, 56]), Op::Store(vec![34, 10, 57]), Op::Store(vec![34, 9, 58]), Op::Store(vec![34, 8, 59]), Op::Store(vec![34, 7, 60]), Op::Store(vec![34, 6, 61]), Op::Store(vec![34, 5, 62]), Op::Store(vec![34, 4, 63]), Op::Store(vec![34, 3, 64]), Op::Store(vec![34, 2, 65])], ctrl: Ctrl::Return(0, vec![66]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 65, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_243() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(256)), Op::Mul(33, 2), Op::Const(G::from_u64(65536)), Op::Mul(35, 3), Op::Const(G::from_u64(16777216)), Op::Mul(37, 4), Op::Add(36, 38), Op::Add(34, 39), Op::Add(1, 40), Op::Mul(33, 6), Op::Mul(35, 7), Op::Mul(37, 8), Op::Add(43, 44), Op::Add(42, 45), Op::Add(5, 46), Op::Mul(33, 10), Op::Mul(35, 11), Op::Mul(37, 12), Op::Add(49, 50), Op::Add(48, 51), Op::Add(9, 52), Op::Mul(33, 14), Op::Mul(35, 15), Op::Mul(37, 16), Op::Add(55, 56), Op::Add(54, 57), Op::Add(13, 58), Op::Mul(33, 18), Op::Mul(35, 19), Op::Mul(37, 20), Op::Add(61, 62), Op::Add(60, 63), Op::Add(17, 64), Op::Mul(33, 22), Op::Mul(35, 23), Op::Mul(37, 24), Op::Add(67, 68), Op::Add(66, 69), Op::Add(21, 70), Op::Mul(33, 26), Op::Mul(35, 27), Op::Mul(37, 28), Op::Add(73, 74), Op::Add(72, 75), Op::Add(25, 76), Op::Mul(33, 30), Op::Mul(35, 31), Op::Mul(37, 32), Op::Add(79, 80), Op::Add(78, 81), Op::Add(29, 82)], ctrl: Ctrl::Return(0, vec![41, 47, 53, 59, 65, 71, 77, 83]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_244() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(242, vec![1, 3], 1, false), Op::Call(242, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 2, 5]), Op::Call(75, vec![7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_245() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(242, vec![0, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 3]), Op::Call(75, vec![5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_246() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(0, 4), Op::Add(5, 1), Op::Mul(6, 4), Op::Add(7, 2), Op::Mul(8, 4), Op::Add(9, 3)], ctrl: Ctrl::Return(0, vec![10]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_247() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(256)), Op::Mul(2, 66), Op::Add(67, 3), Op::Mul(68, 66), Op::Add(69, 4), Op::Mul(70, 66), Op::Add(71, 5), Op::Mul(34, 66), Op::Add(73, 35), Op::Mul(74, 66), Op::Add(75, 36), Op::Mul(76, 66), Op::Add(77, 37), Op::Sub(72, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(6, 80), Op::Add(81, 7), Op::Mul(82, 80), Op::Add(83, 8), Op::Mul(84, 80), Op::Add(85, 9), Op::Mul(38, 80), Op::Add(87, 39), Op::Mul(88, 80), Op::Add(89, 40), Op::Mul(90, 80), Op::Add(91, 41), Op::Sub(86, 92)], ctrl: Ctrl::Match(93, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(10, 94), Op::Add(95, 11), Op::Mul(96, 94), Op::Add(97, 12), Op::Mul(98, 94), Op::Add(99, 13), Op::Mul(42, 94), Op::Add(101, 43), Op::Mul(102, 94), Op::Add(103, 44), Op::Mul(104, 94), Op::Add(105, 45), Op::Sub(100, 106)], ctrl: Ctrl::Match(107, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(14, 108), Op::Add(109, 15), Op::Mul(110, 108), Op::Add(111, 16), Op::Mul(112, 108), Op::Add(113, 17), Op::Mul(46, 108), Op::Add(115, 47), Op::Mul(116, 108), Op::Add(117, 48), Op::Mul(118, 108), Op::Add(119, 49), Op::Sub(114, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(18, 122), Op::Add(123, 19), Op::Mul(124, 122), Op::Add(125, 20), Op::Mul(126, 122), Op::Add(127, 21), Op::Mul(50, 122), Op::Add(129, 51), Op::Mul(130, 122), Op::Add(131, 52), Op::Mul(132, 122), Op::Add(133, 53), Op::Sub(128, 134)], ctrl: Ctrl::Match(135, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(22, 136), Op::Add(137, 23), Op::Mul(138, 136), Op::Add(139, 24), Op::Mul(140, 136), Op::Add(141, 25), Op::Mul(54, 136), Op::Add(143, 55), Op::Mul(144, 136), Op::Add(145, 56), Op::Mul(146, 136), Op::Add(147, 57), Op::Sub(142, 148)], ctrl: Ctrl::Match(149, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(26, 150), Op::Add(151, 27), Op::Mul(152, 150), Op::Add(153, 28), Op::Mul(154, 150), Op::Add(155, 29), Op::Mul(58, 150), Op::Add(157, 59), Op::Mul(158, 150), Op::Add(159, 60), Op::Mul(160, 150), Op::Add(161, 61), Op::Sub(156, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(30, 164), Op::Add(165, 31), Op::Mul(166, 164), Op::Add(167, 32), Op::Mul(168, 164), Op::Add(169, 33), Op::Mul(62, 164), Op::Add(171, 63), Op::Mul(172, 164), Op::Add(173, 64), Op::Mul(174, 164), Op::Add(175, 65), Op::Sub(170, 176)], ctrl: Ctrl::Match(177, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![178]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(170, 176)], ctrl: Ctrl::Match(178, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![179]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![179]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(156, 162)], ctrl: Ctrl::Match(164, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![165]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![165]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(142, 148)], ctrl: Ctrl::Match(150, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![151]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(6, vec![151]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(128, 134)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![137]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(8, vec![137]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(114, 120)], ctrl: Ctrl::Match(122, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(9, vec![123]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(10, vec![123]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(100, 106)], ctrl: Ctrl::Match(108, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![109]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(12, vec![109]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(86, 92)], ctrl: Ctrl::Match(94, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![95]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(14, vec![95]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(72, 78)], ctrl: Ctrl::Match(80, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(15, vec![81]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(16, vec![81]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 17, auxiliaries: 73, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_248() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![2, 5], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("aggr: tree leaves are not strictly sorted".into())), Op::Call(248, vec![3], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_249() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(241, vec![2], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![5, 3, 7])], ctrl: Ctrl::Return(0, vec![8, 4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(1, vec![4, 2]) }), (G::from_u64(2), Block { ops: vec![Op::Call(249, vec![2], 2, false), Op::Call(249, vec![4], 2, false), Op::Call(298, vec![3, 5], 1, false)], ctrl: Ctrl::Return(2, vec![7, 6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_250() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(245, vec![2], 1, false), Op::Call(250, vec![3], 1, false), Op::Store(vec![4, 5, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_251() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]), Op::Call(244, vec![2, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Store(vec![7, 9, 11])], ctrl: Ctrl::Return(1, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(244, vec![2, 5], 1, false), Op::Call(251, vec![6], 1, false), Op::Store(vec![7, 8, 9])], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 11, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_252() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(251, vec![0], 1, false), Op::Call(252, vec![7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_253() -> Function { + Function { body: Block { ops: vec![Op::Call(250, vec![0], 1, false), Op::Call(252, vec![1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_254() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(5)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(3, vec![33, 34, 35], 1, true), Op::Call(87, vec![36], 2, false), Op::Const(G::from_u64(226)), Op::AssertEq(vec![37], vec![39], Some("aggr: tree has the wrong Ixon tag".into())), Op::Call(249, vec![38], 2, false), Op::Load(3, 41), Op::Const(G::from_u64(1)), Op::AssertEq(vec![42, 43, 44], vec![45, 45, 45], Some("aggr: trailing bytes after AssumptionTree".into())), Op::Call(304, vec![40], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![46], vec![47], Some("aggr: a present tree must contain at least one leaf".into())), Op::Call(248, vec![40], 0, false), Op::Call(253, vec![40], 1, false), Op::Call(2, vec![48, 0], 1, false), Op::AssertEq(vec![49], vec![45], Some("aggr: tree leaves do not reproduce the canonical root".into()))], ctrl: Ctrl::Return(0, vec![40]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 46, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_255() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Call(254, vec![1], 1, false)], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_256() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0), Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![3, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], Some("aggr: set element mismatch".into())), Op::Call(256, vec![4, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_257() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0), Op::Load(3, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(256, vec![1, 2], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(256, vec![0, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(247, vec![4, 7], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![4, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: subject union mismatch".into())), Op::Call(257, vec![5, 1, 11], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(2, vec![4, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: subject union mismatch".into())), Op::Call(257, vec![5, 8, 11], 0, false)], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(2, vec![7, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: subject union mismatch".into())), Op::Call(257, vec![0, 8, 11], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_258() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0), Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8, 6, 0, 7]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8, 3, 4, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9, 3, 4, 1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![9, 3, 4, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![9, 6, 0, 7]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_259() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![3, 0], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(259, vec![0, 4], 2, false)], ctrl: Ctrl::Return(1, vec![6, 7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![6, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![6, 1]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_260() -> Function { + Function { body: Block { ops: vec![Op::Call(258, vec![0, 1], 4, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8, 9, 10], vec![11, 11, 11], Some("aggr: output has an extra assumption".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(259, vec![5, 2], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(260, vec![6, 7, 9, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![5, 11], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: outstanding assumption mismatch".into())), Op::Call(260, vec![6, 7, 9, 12], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_261() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(2)), Op::U8LessThan(3, 5), Op::Const(G::from_u64(1)), Op::AssertEq(vec![6], vec![7], Some("aggr structural: path side must be 0 or 1".into())), Op::Call(241, vec![4], 2, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![Op::Call(244, vec![8, 0], 1, false)], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, vec![0, 8], 1, false)], ctrl: Ctrl::Yield(2, vec![10]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(261, vec![10, 12, 9], 2, false)], ctrl: Ctrl::Return(3, vec![13, 14]) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_262() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Load(32, 0), Op::IOGetInfo(2, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Call(3, vec![2, 35, 36], 1, true), Op::Call(87, vec![37], 2, false), Op::Const(G::from_u64(2)), Op::U8LessThan(38, 40), Op::Const(G::from_u64(1)), Op::AssertEq(vec![41], vec![42], Some("aggr structural: discharge choice must be 0 or 1".into()))], ctrl: Ctrl::Match(38, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39), Op::Const(G::from_u64(1)), Op::AssertEq(vec![43, 44, 45], vec![46, 46, 46], Some("aggr structural: carried choice has trailing bytes".into())), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![39], 2, false), Op::Const(G::from_u64(65)), Op::U8LessThan(43, 45), Op::Const(G::from_u64(1)), Op::AssertEq(vec![46], vec![47], Some("aggr structural: Merkle path exceeds 64 steps".into())), Op::Call(245, vec![0], 1, false), Op::Call(261, vec![48, 43, 44], 2, false), Op::Load(3, 50), Op::AssertEq(vec![51, 52, 53], vec![47, 47, 47], Some("aggr structural: trailing bytes after Merkle path".into())), Op::Call(2, vec![49, 1], 1, false), Op::AssertEq(vec![54], vec![47], Some("aggr structural: assumption path does not reach subject root".into()))], ctrl: Ctrl::Return(1, vec![47]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_263() -> Function { + Function { body: Block { ops: vec![Op::Call(258, vec![0, 1], 4, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8, 9, 10], vec![11, 11, 11], Some("aggr structural: output has an extra assumption".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(262, vec![5, 2], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(263, vec![6, 7, 2, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![5, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("aggr structural: outstanding assumption mismatch".into())), Op::Call(263, vec![6, 7, 2, 11], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_264() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(241, vec![2], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_265() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Const(G::from_u64(229)), Op::AssertEq(vec![1], vec![3], Some("aggr: claim is not CheckEnv".into())), Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(3)), Op::AssertEq(vec![4], vec![6], Some("aggr: unsupported object format".into())), Op::Call(87, vec![5], 2, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![9], Some("aggr: wrong validator identity".into())), Op::Call(241, vec![8], 2, false), Op::Call(264, vec![11], 3, false), Op::Load(3, 14), Op::AssertEq(vec![15, 16, 17], vec![9, 9, 9], Some("aggr: trailing bytes after CheckEnv claim".into()))], ctrl: Ctrl::Return(0, vec![10, 12, 13]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_266() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(4)), Op::IOGetInfo(8, vec![0, 1, 2, 3, 4, 5, 6, 7]), Op::Call(3, vec![8, 9, 10], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![43, 43, 43]), Op::Const(G::from_u64(0)), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45]), Op::Store(vec![12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42]), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Call(78, vec![11, 44, 45, 45, 46, 47, 48], 1, false), Op::Call(77, vec![49], 32, false), Op::Const(G::from_u64(256)), Op::Mul(82, 51), Op::Const(G::from_u64(65536)), Op::Mul(84, 52), Op::Const(G::from_u64(16777216)), Op::Mul(86, 53), Op::Add(85, 87), Op::Add(83, 88), Op::Add(50, 89), Op::Mul(82, 55), Op::Mul(84, 56), Op::Mul(86, 57), Op::Add(92, 93), Op::Add(91, 94), Op::Add(54, 95), Op::Mul(82, 59), Op::Mul(84, 60), Op::Mul(86, 61), Op::Add(98, 99), Op::Add(97, 100), Op::Add(58, 101), Op::Mul(82, 63), Op::Mul(84, 64), Op::Mul(86, 65), Op::Add(104, 105), Op::Add(103, 106), Op::Add(62, 107), Op::Mul(82, 67), Op::Mul(84, 68), Op::Mul(86, 69), Op::Add(110, 111), Op::Add(109, 112), Op::Add(66, 113), Op::Mul(82, 71), Op::Mul(84, 72), Op::Mul(86, 73), Op::Add(116, 117), Op::Add(115, 118), Op::Add(70, 119), Op::Mul(82, 75), Op::Mul(84, 76), Op::Mul(86, 77), Op::Add(122, 123), Op::Add(121, 124), Op::Add(74, 125), Op::Mul(82, 79), Op::Mul(84, 80), Op::Mul(86, 81), Op::Add(128, 129), Op::Add(127, 130), Op::Add(78, 131), Op::AssertEq(vec![90, 96, 102, 108, 114, 120, 126, 132], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("aggr: claim preimage digest mismatch".into()))], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 41, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_267() -> Function { + Function { body: Block { ops: vec![Op::Call(310, vec![0, 1], 8, false), Op::Const(G::from_u64(256)), Op::Mul(10, 3), Op::Const(G::from_u64(65536)), Op::Mul(12, 4), Op::Const(G::from_u64(16777216)), Op::Mul(14, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 9), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(2, 29)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_268() -> Function { + Function { body: Block { ops: vec![Op::Call(267, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Call(267, vec![0, 4], 1, false), Op::Const(G::from_u64(2)), Op::Add(1, 6), Op::Call(267, vec![0, 7], 1, false), Op::Const(G::from_u64(3)), Op::Add(1, 9), Op::Call(267, vec![0, 10], 1, false), Op::Const(G::from_u64(4)), Op::Add(1, 12), Op::Call(267, vec![0, 13], 1, false), Op::Const(G::from_u64(5)), Op::Add(1, 15), Op::Call(267, vec![0, 16], 1, false), Op::Const(G::from_u64(6)), Op::Add(1, 18), Op::Call(267, vec![0, 19], 1, false), Op::Const(G::from_u64(7)), Op::Add(1, 21), Op::Call(267, vec![0, 22], 1, false)], ctrl: Ctrl::Return(0, vec![2, 5, 8, 11, 14, 17, 20, 23]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_269() -> Function { + Function { body: Block { ops: vec![Op::AssertEq(vec![0], vec![8], None), Op::AssertEq(vec![1], vec![9], None), Op::AssertEq(vec![2], vec![10], None), Op::AssertEq(vec![3], vec![11], None), Op::AssertEq(vec![4], vec![12], None), Op::AssertEq(vec![5], vec![13], None), Op::AssertEq(vec![6], vec![14], None), Op::AssertEq(vec![7], vec![15], None)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_270() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4, 5, 6], vec![7, 7, 7], Some("aggr: child proof must expose exactly one claim".into()))], ctrl: Ctrl::Return(0, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_271() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::IOGetInfo(17, vec![0]), Op::Call(3, vec![17, 18, 19], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![17, 17, 17]), Op::Const(G::from_u64(0)), Op::Store(vec![53, 53, 53, 53, 53, 53, 53, 53]), Op::Store(vec![21, 22, 23, 24, 25, 26, 21, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]), Op::Store(vec![17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17]), Op::Call(78, vec![20, 52, 53, 53, 54, 55, 56], 1, false), Op::Call(77, vec![57], 32, false), Op::Const(G::from_u64(256)), Op::Mul(90, 59), Op::Const(G::from_u64(65536)), Op::Mul(92, 60), Op::Const(G::from_u64(16777216)), Op::Mul(94, 61), Op::Add(93, 95), Op::Add(91, 96), Op::Add(58, 97), Op::Mul(90, 63), Op::Mul(92, 64), Op::Mul(94, 65), Op::Add(100, 101), Op::Add(99, 102), Op::Add(62, 103), Op::Mul(90, 67), Op::Mul(92, 68), Op::Mul(94, 69), Op::Add(106, 107), Op::Add(105, 108), Op::Add(66, 109), Op::Mul(90, 71), Op::Mul(92, 72), Op::Mul(94, 73), Op::Add(112, 113), Op::Add(111, 114), Op::Add(70, 115), Op::Mul(90, 75), Op::Mul(92, 76), Op::Mul(94, 77), Op::Add(118, 119), Op::Add(117, 120), Op::Add(74, 121), Op::Mul(90, 79), Op::Mul(92, 80), Op::Mul(94, 81), Op::Add(124, 125), Op::Add(123, 126), Op::Add(78, 127), Op::Mul(90, 83), Op::Mul(92, 84), Op::Mul(94, 85), Op::Add(130, 131), Op::Add(129, 132), Op::Add(82, 133), Op::Mul(90, 87), Op::Mul(92, 88), Op::Mul(94, 89), Op::Add(136, 137), Op::Add(135, 138), Op::Add(86, 139)], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Call(269, vec![98, 104, 110, 116, 122, 128, 134, 140, 1, 2, 3, 4, 5, 6, 7, 8], 0, false)], ctrl: Ctrl::Yield(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(269, vec![98, 104, 110, 116, 122, 128, 134, 140, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Call(90, vec![20], 10, false), Op::Call(90, vec![150], 10, false), Op::Call(90, vec![160], 10, false), Op::Call(90, vec![170], 10, false), Op::Call(90, vec![180], 10, false), Op::Call(90, vec![190], 10, false), Op::Call(90, vec![200], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![212, 212, 212, 212, 212, 212, 212, 212, 212, 212]), Op::Store(vec![211, 202, 203, 204, 205, 206, 207, 208, 209, 213]), Op::Store(vec![211, 192, 193, 194, 195, 196, 197, 198, 199, 214]), Op::Store(vec![211, 182, 183, 184, 185, 186, 187, 188, 189, 215]), Op::Store(vec![211, 172, 173, 174, 175, 176, 177, 178, 179, 216]), Op::Store(vec![211, 162, 163, 164, 165, 166, 167, 168, 169, 217]), Op::Store(vec![211, 152, 153, 154, 155, 156, 157, 158, 159, 218]), Op::Store(vec![211, 142, 143, 144, 145, 146, 147, 148, 149, 219]), Op::Call(90, vec![210], 10, false), Op::Call(103, vec![230, 221], 3, false), Op::Call(104, vec![233], 3, false), Op::Call(105, vec![236, 221], 2, false), Op::Store(vec![211, 222, 223, 224, 225, 226, 227, 228, 229, 232]), Op::Call(306, vec![220, 239], 1, false), Op::Load(3, 238), Op::AssertEq(vec![241, 242, 243], vec![212, 212, 212], None)], ctrl: Ctrl::Return(2, vec![141, 151, 161, 171, 181, 191, 201, 240, 231, 234, 235, 237]) })) }, layout: FunctionLayout { input_size: 17, selectors: 3, auxiliaries: 143, lookups: 30 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_272() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(13, vec![12]), Op::Const(G::from_u64(2)), Op::IOGetInfo(16, vec![12]), Op::Call(3, vec![16, 17, 18], 1, true), Op::Call(28, vec![19], 2, false), Op::Call(238, vec![21, 20], 2, false), Op::Load(3, 23), Op::Const(G::from_u64(1)), Op::AssertEq(vec![24, 25, 26], vec![27, 27, 27], None), Op::Call(31, vec![14], 2, false), Op::Call(65, vec![29, 28], 2, false), Op::Call(31, vec![31], 2, false), Op::Call(68, vec![33, 32], 2, false), Op::Call(31, vec![35], 2, false), Op::Call(70, vec![37, 36], 2, false), Op::Add(14, 15), Op::AssertEq(vec![39], vec![40], None), Op::Call(235, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 30, 34, 38], 1, false), Op::Call(220, vec![41, 22], 1, false), Op::AssertEq(vec![42], vec![27], None), Op::AssertEq(vec![27], vec![27], None)], ctrl: Ctrl::Return(0, vec![22]) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 27, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_273() -> Function { + Function { body: Block { ops: vec![Op::Call(271, vec![0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 12, false), Op::Call(272, vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1], 1, false), Op::Call(270, vec![40], 1, false), Op::Const(G::from_u64(0)), Op::Call(267, vec![41, 42], 1, false), Op::AssertEq(vec![43], vec![42], Some("aggr: child has the wrong claim channel".into()))], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(301, vec![41], 1, false), Op::Const(G::from_u64(10)), Op::AssertEq(vec![44], vec![45], Some("aggr: IxVM child must expose a 10-word verify_claim claim".into())), Op::Const(G::from_u64(1)), Op::Call(267, vec![41, 46], 1, false), Op::AssertEq(vec![47], vec![18], Some("aggr: IxVM child has the wrong entrypoint".into())), Op::Const(G::from_u64(2)), Op::Call(268, vec![41, 48], 8, false)], ctrl: Ctrl::Return(0, vec![49, 50, 51, 52, 53, 54, 55, 56]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![41], 1, false), Op::Const(G::from_u64(18)), Op::AssertEq(vec![44], vec![45], Some("aggr: recursive child must expose an 18-word ix_aggr claim".into())), Op::Const(G::from_u64(1)), Op::Call(267, vec![41, 46], 1, false), Op::AssertEq(vec![47], vec![19], Some("aggr: recursive child has the wrong entrypoint".into())), Op::Const(G::from_u64(2)), Op::Call(268, vec![41, 48], 8, false), Op::Call(269, vec![49, 50, 51, 52, 53, 54, 55, 56, 20, 21, 22, 23, 24, 25, 26, 27], 0, false), Op::Const(G::from_u64(10)), Op::Call(268, vec![41, 57], 8, false)], ctrl: Ctrl::Return(1, vec![58, 59, 60, 61, 62, 63, 64, 65]) }))) }, layout: FunctionLayout { input_size: 28, selectors: 2, auxiliaries: 35, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_274() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(273, vec![0, 35, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26], 8, false), Op::Call(269, vec![36, 37, 38, 39, 40, 41, 42, 43, 27, 28, 29, 30, 31, 32, 33, 34], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 35, selectors: 1, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_275() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(273, vec![0, 36, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Const(G::from_u64(1)), Op::Call(273, vec![1, 45, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Call(266, vec![37, 38, 39, 40, 41, 42, 43, 44], 1, false), Op::Call(265, vec![54], 3, false), Op::Call(266, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Call(265, vec![58], 3, false), Op::Const(G::from_u64(2)), Op::IOGetInfo(62, vec![62]), Op::Call(3, vec![62, 63, 64], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![45, 45, 45]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36]), Op::Store(vec![66, 67, 68, 69, 70, 71, 66, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96]), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45]), Op::Call(78, vec![65, 97, 36, 36, 98, 99, 100], 1, false), Op::Call(77, vec![101], 32, false), Op::Const(G::from_u64(256)), Op::Mul(134, 103), Op::Const(G::from_u64(65536)), Op::Mul(136, 104), Op::Const(G::from_u64(16777216)), Op::Mul(138, 105), Op::Add(137, 139), Op::Add(135, 140), Op::Add(102, 141), Op::Mul(134, 107), Op::Mul(136, 108), Op::Mul(138, 109), Op::Add(144, 145), Op::Add(143, 146), Op::Add(106, 147), Op::Mul(134, 111), Op::Mul(136, 112), Op::Mul(138, 113), Op::Add(150, 151), Op::Add(149, 152), Op::Add(110, 153), Op::Mul(134, 115), Op::Mul(136, 116), Op::Mul(138, 117), Op::Add(156, 157), Op::Add(155, 158), Op::Add(114, 159), Op::Mul(134, 119), Op::Mul(136, 120), Op::Mul(138, 121), Op::Add(162, 163), Op::Add(161, 164), Op::Add(118, 165), Op::Mul(134, 123), Op::Mul(136, 124), Op::Mul(138, 125), Op::Add(168, 169), Op::Add(167, 170), Op::Add(122, 171), Op::Mul(134, 127), Op::Mul(136, 128), Op::Mul(138, 129), Op::Add(174, 175), Op::Add(173, 176), Op::Add(126, 177), Op::Mul(134, 131), Op::Mul(136, 132), Op::Mul(138, 133), Op::Add(180, 181), Op::Add(179, 182), Op::Add(130, 183), Op::AssertEq(vec![142, 148, 154, 160, 166, 172, 178, 184], vec![28, 29, 30, 31, 32, 33, 34, 35], Some("aggr: output claim digest mismatch".into())), Op::Call(265, vec![65], 3, false), Op::Call(254, vec![55], 1, false), Op::Call(254, vec![59], 1, false), Op::Call(255, vec![56, 57], 1, false), Op::Call(255, vec![60, 61], 1, false), Op::Call(254, vec![185], 1, false), Op::Call(255, vec![186, 187], 1, false), Op::Call(257, vec![188, 189, 192], 0, false), Op::Call(260, vec![190, 191, 192, 193], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 36, selectors: 1, auxiliaries: 74, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_276() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(273, vec![0, 36, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Const(G::from_u64(1)), Op::Call(273, vec![1, 45, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Call(266, vec![37, 38, 39, 40, 41, 42, 43, 44], 1, false), Op::Call(265, vec![54], 3, false), Op::Call(266, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Call(265, vec![58], 3, false), Op::Const(G::from_u64(2)), Op::IOGetInfo(62, vec![62]), Op::Call(3, vec![62, 63, 64], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![45, 45, 45]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36]), Op::Store(vec![66, 67, 68, 69, 70, 71, 66, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96]), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45]), Op::Call(78, vec![65, 97, 36, 36, 98, 99, 100], 1, false), Op::Call(77, vec![101], 32, false), Op::Const(G::from_u64(256)), Op::Mul(134, 103), Op::Const(G::from_u64(65536)), Op::Mul(136, 104), Op::Const(G::from_u64(16777216)), Op::Mul(138, 105), Op::Add(137, 139), Op::Add(135, 140), Op::Add(102, 141), Op::Mul(134, 107), Op::Mul(136, 108), Op::Mul(138, 109), Op::Add(144, 145), Op::Add(143, 146), Op::Add(106, 147), Op::Mul(134, 111), Op::Mul(136, 112), Op::Mul(138, 113), Op::Add(150, 151), Op::Add(149, 152), Op::Add(110, 153), Op::Mul(134, 115), Op::Mul(136, 116), Op::Mul(138, 117), Op::Add(156, 157), Op::Add(155, 158), Op::Add(114, 159), Op::Mul(134, 119), Op::Mul(136, 120), Op::Mul(138, 121), Op::Add(162, 163), Op::Add(161, 164), Op::Add(118, 165), Op::Mul(134, 123), Op::Mul(136, 124), Op::Mul(138, 125), Op::Add(168, 169), Op::Add(167, 170), Op::Add(122, 171), Op::Mul(134, 127), Op::Mul(136, 128), Op::Mul(138, 129), Op::Add(174, 175), Op::Add(173, 176), Op::Add(126, 177), Op::Mul(134, 131), Op::Mul(136, 132), Op::Mul(138, 133), Op::Add(180, 181), Op::Add(179, 182), Op::Add(130, 183), Op::AssertEq(vec![142, 148, 154, 160, 166, 172, 178, 184], vec![28, 29, 30, 31, 32, 33, 34, 35], Some("aggr structural: output claim digest mismatch".into())), Op::Call(265, vec![65], 3, false), Op::Call(244, vec![55, 59], 1, false), Op::Call(2, vec![185, 188], 1, false), Op::AssertEq(vec![189], vec![45], Some("aggr structural: output subject root is not nodeHash(left, right)".into())), Op::Call(255, vec![56, 57], 1, false), Op::Call(255, vec![60, 61], 1, false), Op::Call(255, vec![186, 187], 1, false), Op::Call(263, vec![190, 191, 185, 192], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 36, selectors: 1, auxiliaries: 73, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_277() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Const(G::from_u64(82)), Op::AssertEq(vec![1], vec![3], Some("aggr range: statement has the wrong tag".into())), Op::Call(241, vec![2], 2, false), Op::Call(26, vec![5], 2, false), Op::Call(26, vec![7], 2, false), Op::Call(26, vec![9], 2, false), Op::Call(26, vec![11], 2, false), Op::Call(26, vec![13], 2, false), Op::Call(26, vec![15], 2, false), Op::Call(26, vec![17], 2, false), Op::Call(26, vec![19], 2, false), Op::Call(26, vec![21], 2, false), Op::Call(26, vec![23], 2, false), Op::Call(26, vec![25], 2, false), Op::Call(26, vec![27], 2, false), Op::Call(26, vec![29], 2, false), Op::Call(26, vec![31], 2, false), Op::Call(26, vec![33], 2, false), Op::Call(26, vec![35], 2, false), Op::Call(26, vec![37], 2, false), Op::Call(26, vec![39], 2, false), Op::Call(26, vec![41], 2, false), Op::Call(26, vec![43], 2, false), Op::Call(26, vec![45], 2, false), Op::Call(26, vec![47], 2, false), Op::Call(26, vec![49], 2, false), Op::Call(26, vec![51], 2, false), Op::Call(26, vec![53], 2, false), Op::Call(26, vec![55], 2, false), Op::Call(26, vec![57], 2, false), Op::Call(26, vec![59], 2, false), Op::Call(26, vec![61], 2, false), Op::Call(26, vec![63], 2, false), Op::Call(26, vec![65], 2, false), Op::Call(26, vec![67], 2, false), Op::Load(3, 69), Op::Const(G::from_u64(1)), Op::AssertEq(vec![70, 71, 72], vec![73, 73, 73], Some("aggr range: trailing bytes after the statement".into())), Op::Const(G::from_u64(256)), Op::Mul(74, 40), Op::Const(G::from_u64(65536)), Op::Mul(76, 42), Op::Const(G::from_u64(16777216)), Op::Mul(78, 44), Op::Const(G::from_u64(4294967296)), Op::Mul(80, 46), Op::Const(G::from_u64(1099511627776)), Op::Mul(82, 48), Op::Const(G::from_u64(281474976710656)), Op::Mul(84, 50), Op::Const(G::from_u64(72057594037927936)), Op::Mul(86, 52), Op::Add(85, 87), Op::Add(83, 88), Op::Add(81, 89), Op::Add(79, 90), Op::Add(77, 91), Op::Add(75, 92), Op::Add(38, 93), Op::Mul(74, 56), Op::Mul(76, 58), Op::Mul(78, 60), Op::Mul(80, 62), Op::Mul(82, 64), Op::Mul(84, 66), Op::Mul(86, 68), Op::Add(100, 101), Op::Add(99, 102), Op::Add(98, 103), Op::Add(97, 104), Op::Add(96, 105), Op::Add(95, 106), Op::Add(54, 107)], ctrl: Ctrl::Return(0, vec![4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 94, 108]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 72, lookups: 36 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_278() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(26, vec![2], 2, false), Op::Call(26, vec![4], 2, false), Op::Call(26, vec![6], 2, false), Op::Call(26, vec![8], 2, false), Op::Call(26, vec![10], 2, false), Op::Call(26, vec![12], 2, false), Op::Call(26, vec![14], 2, false), Op::Call(26, vec![16], 2, false), Op::Call(26, vec![18], 2, false), Op::Call(26, vec![20], 2, false), Op::Call(26, vec![22], 2, false), Op::Call(26, vec![24], 2, false), Op::Call(26, vec![26], 2, false), Op::Call(26, vec![28], 2, false), Op::Call(26, vec![30], 2, false), Op::Call(26, vec![32], 2, false), Op::Call(26, vec![34], 2, false), Op::Call(26, vec![36], 2, false), Op::Call(26, vec![38], 2, false), Op::Call(26, vec![40], 2, false), Op::Call(26, vec![42], 2, false), Op::Call(26, vec![44], 2, false), Op::Call(26, vec![46], 2, false), Op::Call(26, vec![48], 2, false), Op::Call(26, vec![50], 2, false), Op::Call(26, vec![52], 2, false), Op::Call(26, vec![54], 2, false), Op::Call(26, vec![56], 2, false), Op::Call(26, vec![58], 2, false), Op::Call(26, vec![60], 2, false), Op::Call(26, vec![62], 2, false), Op::Store(vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63])], ctrl: Ctrl::Return(0, vec![65, 64]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 66, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_279() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(278, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(279, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_280() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(280, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_281() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 9, false), Op::Call(14, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(280, vec![9, 10], 2, false), Op::Call(27, vec![12], 9, false), Op::Call(14, vec![13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(279, vec![21, 22], 2, false), Op::Call(27, vec![24], 9, false), Op::Call(14, vec![25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Call(280, vec![33, 34], 2, false), Op::Call(28, vec![36], 2, false), Op::Call(238, vec![38, 37], 2, false)], ctrl: Ctrl::Return(0, vec![11, 23, 35, 39, 40]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_282() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(281, vec![0], 5, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(282, vec![6, 8], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 9])], ctrl: Ctrl::Return(1, vec![12, 10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_283() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(240, vec![2, 1], 2, false), Op::Call(26, vec![4], 2, false), Op::Call(26, vec![6], 2, false), Op::Call(26, vec![8], 2, false), Op::Call(26, vec![10], 2, false), Op::Call(26, vec![12], 2, false), Op::Call(26, vec![14], 2, false), Op::Call(26, vec![16], 2, false), Op::Call(26, vec![18], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 7, 9, 11, 13, 15, 17, 19, 20]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_284() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![0], 10, false), Op::Const(G::from_u64(1)), Op::Sub(1, 12), Op::Call(284, vec![11, 13], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 14])], ctrl: Ctrl::Return(1, vec![17, 15]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_285() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(2, vec![0]), Op::Call(3, vec![2, 3, 4], 1, true), Op::Call(75, vec![5], 1, false), Op::Call(2, vec![6, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("aggr range: preamble does not hash to the statement's batch digest".into())), Op::Call(27, vec![5], 9, false), Op::Call(14, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(282, vec![17, 18], 2, false), Op::Call(27, vec![20], 9, false), Op::Call(14, vec![21, 22, 23, 24, 25, 26, 27, 28], 1, false), Op::Call(284, vec![29, 30], 2, false), Op::Load(3, 32), Op::AssertEq(vec![33, 34, 35], vec![8, 8, 8], Some("aggr range: trailing bytes after the preamble".into()))], ctrl: Ctrl::Return(0, vec![19, 31]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 33, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_286() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Yield(0, vec![15]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(216, vec![7, 14, 12, 13], 5, false)], ctrl: Ctrl::Return(2, vec![15, 16, 17, 18, 19]) })) }))) }, layout: FunctionLayout { input_size: 14, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_287() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![21, 22, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Call(62, vec![13], 25, false), Op::Call(232, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 24, 25, 26, 27, 14, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 16, 17, 18, 19, 20], 2, false), Op::Const(G::from_u64(1)), Op::Add(14, 56), Op::Sub(15, 56), Op::Add(21, 54), Op::Add(22, 55), Op::Call(287, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 28, 53, 57, 58, 16, 17, 18, 19, 20, 59, 60], 3, false)], ctrl: Ctrl::Return(1, vec![61, 62, 63]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 23, selectors: 2, auxiliaries: 38, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_288() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::IOGetInfo(8, vec![8]), Op::Call(3, vec![8, 9, 10], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![43, 43, 43]), Op::Const(G::from_u64(0)), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45]), Op::Store(vec![12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42]), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Call(78, vec![11, 44, 45, 45, 46, 47, 48], 1, false), Op::Call(77, vec![49], 32, false), Op::Const(G::from_u64(256)), Op::Mul(82, 51), Op::Const(G::from_u64(65536)), Op::Mul(84, 52), Op::Const(G::from_u64(16777216)), Op::Mul(86, 53), Op::Add(85, 87), Op::Add(83, 88), Op::Add(50, 89), Op::Mul(82, 55), Op::Mul(84, 56), Op::Mul(86, 57), Op::Add(92, 93), Op::Add(91, 94), Op::Add(54, 95), Op::Mul(82, 59), Op::Mul(84, 60), Op::Mul(86, 61), Op::Add(98, 99), Op::Add(97, 100), Op::Add(58, 101), Op::Mul(82, 63), Op::Mul(84, 64), Op::Mul(86, 65), Op::Add(104, 105), Op::Add(103, 106), Op::Add(62, 107), Op::Mul(82, 67), Op::Mul(84, 68), Op::Mul(86, 69), Op::Add(110, 111), Op::Add(109, 112), Op::Add(66, 113), Op::Mul(82, 71), Op::Mul(84, 72), Op::Mul(86, 73), Op::Add(116, 117), Op::Add(115, 118), Op::Add(70, 119), Op::Mul(82, 75), Op::Mul(84, 76), Op::Mul(86, 77), Op::Add(122, 123), Op::Add(121, 124), Op::Add(74, 125), Op::Mul(82, 79), Op::Mul(84, 80), Op::Mul(86, 81), Op::Add(128, 129), Op::Add(127, 130), Op::Add(78, 131), Op::AssertEq(vec![90, 96, 102, 108, 114, 120, 126, 132], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("aggr range: output statement digest mismatch".into())), Op::Call(277, vec![11], 19, false)], ctrl: Ctrl::Return(0, vec![133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 60, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_289() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(273, vec![27, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26], 8, false), Op::Call(266, vec![28, 29, 30, 31, 32, 33, 34, 35], 1, false), Op::Call(277, vec![36], 19, false)], ctrl: Ctrl::Return(0, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]) }, layout: FunctionLayout { input_size: 27, selectors: 1, auxiliaries: 29, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_290() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(271, vec![24, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 12, false), Op::Call(288, vec![16, 17, 18, 19, 20, 21, 22, 23], 19, false), Op::Call(285, vec![24, 37], 2, false), Op::Call(286, vec![25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 56, 57], 5, false), Op::Call(230, vec![38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![63], vec![64], Some("aggr range: the range ends before it starts".into())), Op::Call(14, vec![38, 39, 40, 41, 42, 43, 44, 45], 1, false), Op::Call(14, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Sub(66, 65), Op::IOGetInfo(24, vec![64]), Op::Call(31, vec![68], 2, false), Op::AssertEq(vec![70], vec![67], Some("aggr range: proof count differs from the range".into())), Op::Call(309, vec![56, 65], 1, false), Op::Call(287, vec![25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 72, 71, 65, 67, 62, 58, 59, 60, 61, 24, 24], 3, false), Op::Add(68, 69), Op::AssertEq(vec![75], vec![76], Some("aggr range: trailing bytes after the proofs".into())), Op::Sub(73, 54), Op::EqZero(77), Op::Sub(74, 55), Op::EqZero(79), Op::Mul(78, 80), Op::AssertEq(vec![81], vec![64], Some("aggr range: residual sum differs from the statement".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 55, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_291() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(289, vec![34, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], 19, false), Op::Const(G::from_u64(1)), Op::Call(289, vec![54, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], 19, false), Op::Call(288, vec![26, 27, 28, 29, 30, 31, 32, 33], 19, false), Op::Call(2, vec![35, 55], 1, false), Op::AssertEq(vec![93], vec![54], Some("aggr range: children verify different batches".into())), Op::Call(2, vec![74, 35], 1, false), Op::AssertEq(vec![94], vec![54], Some("aggr range: output names a different batch than the children".into())), Op::Call(14, vec![44, 45, 46, 47, 48, 49, 50, 51], 1, false), Op::Call(14, vec![56, 57, 58, 59, 60, 61, 62, 63], 1, false), Op::AssertEq(vec![95], vec![96], Some("aggr range: children are not adjacent".into())), Op::Call(14, vec![75, 76, 77, 78, 79, 80, 81, 82], 1, false), Op::Call(14, vec![36, 37, 38, 39, 40, 41, 42, 43], 1, false), Op::AssertEq(vec![97], vec![98], Some("aggr range: output starts elsewhere than the left child".into())), Op::Call(14, vec![83, 84, 85, 86, 87, 88, 89, 90], 1, false), Op::Call(14, vec![64, 65, 66, 67, 68, 69, 70, 71], 1, false), Op::AssertEq(vec![99], vec![100], Some("aggr range: output ends elsewhere than the right child".into())), Op::Add(52, 72), Op::Add(53, 73), Op::Sub(101, 91), Op::EqZero(103), Op::Sub(102, 92), Op::EqZero(105), Op::Mul(104, 106), Op::AssertEq(vec![107], vec![54], Some("aggr range: output residual is not the children's sum".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 71, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_292() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(289, vec![34, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], 19, false), Op::Call(271, vec![34, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 12, false), Op::Const(G::from_u64(1)), Op::Call(285, vec![66, 35], 2, false), Op::Call(299, vec![67], 1, false), Op::Call(227, vec![69], 1, false), Op::AssertEq(vec![70], vec![66], None), Op::Call(14, vec![36, 37, 38, 39, 40, 41, 42, 43], 1, false), Op::AssertEq(vec![71], vec![34], Some("aggr range: root range does not start at shard 0".into())), Op::Call(14, vec![44, 45, 46, 47, 48, 49, 50, 51], 1, false), Op::AssertEq(vec![72], vec![69], Some("aggr range: root range does not end at the last shard".into())), Op::Call(231, vec![68, 34, 34], 1, false), Op::AssertEq(vec![73], vec![66], None), Op::Call(286, vec![54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 67, 68], 5, false), Op::Call(223, vec![52, 53, 68, 74, 75, 76, 77], 2, false), Op::EqZero(79), Op::EqZero(80), Op::Mul(81, 82), Op::AssertEq(vec![83], vec![66], Some("aggr range: the batch does not balance".into())), Op::Call(234, vec![67], 1, false), Op::Call(270, vec![84], 1, false), Op::Call(301, vec![85], 1, false), Op::Const(G::from_u64(10)), Op::AssertEq(vec![86], vec![87], Some("aggr range: batch must carry a 10-word verify_claim claim".into())), Op::Call(267, vec![85, 34], 1, false), Op::AssertEq(vec![88], vec![34], Some("aggr range: batch claim has the wrong channel".into())), Op::Call(267, vec![85, 66], 1, false), Op::AssertEq(vec![89], vec![16], Some("aggr range: batch claim has the wrong entrypoint".into())), Op::Const(G::from_u64(2)), Op::Call(268, vec![85, 90], 8, false), Op::Call(269, vec![91, 92, 93, 94, 95, 96, 97, 98, 26, 27, 28, 29, 30, 31, 32, 33], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 64, lookups: 18 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_293() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::IOGetInfo(16, vec![17]), Op::Const(G::from_u64(80)), Op::AssertEq(vec![19], vec![20], Some("aggr: allowed blob must be exactly 80 bytes".into())), Op::Call(3, vec![16, 18, 19], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![53, 53, 53]), Op::Store(vec![17, 17, 17, 17, 17, 17, 17, 17]), Op::Store(vec![22, 23, 24, 25, 26, 27, 22, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52]), Op::Store(vec![53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53]), Op::Call(78, vec![21, 54, 17, 17, 55, 56, 57], 1, false), Op::Call(77, vec![58], 32, false), Op::Const(G::from_u64(256)), Op::Mul(91, 60), Op::Const(G::from_u64(65536)), Op::Mul(93, 61), Op::Const(G::from_u64(16777216)), Op::Mul(95, 62), Op::Add(94, 96), Op::Add(92, 97), Op::Add(59, 98), Op::Mul(91, 64), Op::Mul(93, 65), Op::Mul(95, 66), Op::Add(101, 102), Op::Add(100, 103), Op::Add(63, 104), Op::Mul(91, 68), Op::Mul(93, 69), Op::Mul(95, 70), Op::Add(107, 108), Op::Add(106, 109), Op::Add(67, 110), Op::Mul(91, 72), Op::Mul(93, 73), Op::Mul(95, 74), Op::Add(113, 114), Op::Add(112, 115), Op::Add(71, 116), Op::Mul(91, 76), Op::Mul(93, 77), Op::Mul(95, 78), Op::Add(119, 120), Op::Add(118, 121), Op::Add(75, 122), Op::Mul(91, 80), Op::Mul(93, 81), Op::Mul(95, 82), Op::Add(125, 126), Op::Add(124, 127), Op::Add(79, 128), Op::Mul(91, 84), Op::Mul(93, 85), Op::Mul(95, 86), Op::Add(131, 132), Op::Add(130, 133), Op::Add(83, 134), Op::Mul(91, 88), Op::Mul(93, 89), Op::Mul(95, 90), Op::Add(137, 138), Op::Add(136, 139), Op::Add(87, 140), Op::AssertEq(vec![99, 105, 111, 117, 123, 129, 135, 141], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("aggr: allowed blob digest mismatch".into())), Op::Call(241, vec![21], 2, false), Op::Call(26, vec![143], 2, false), Op::Call(26, vec![145], 2, false), Op::Call(26, vec![147], 2, false), Op::Call(26, vec![149], 2, false), Op::Call(26, vec![151], 2, false), Op::Call(26, vec![153], 2, false), Op::Call(26, vec![155], 2, false), Op::Call(26, vec![157], 2, false), Op::Call(241, vec![159], 2, false), Op::Call(26, vec![161], 2, false), Op::Call(26, vec![163], 2, false), Op::Call(26, vec![165], 2, false), Op::Call(26, vec![167], 2, false), Op::Call(26, vec![169], 2, false), Op::Call(26, vec![171], 2, false), Op::Call(26, vec![173], 2, false), Op::Call(26, vec![175], 2, false), Op::Load(3, 177), Op::AssertEq(vec![178, 179, 180], vec![53, 53, 53], Some("aggr: allowed blob must be exactly 80 bytes".into())), Op::Call(243, vec![142], 8, false), Op::Call(243, vec![160], 8, false), Op::Call(14, vec![144, 146, 148, 150, 152, 154, 156, 158], 1, false), Op::Call(14, vec![162, 164, 166, 168, 170, 172, 174, 176], 1, false), Op::Const(G::from_u64(6)), Op::IOGetInfo(199, vec![17]), Op::AssertEq(vec![201], vec![53], Some("aggr: shape hint must be exactly one byte".into())), Op::Call(3, vec![199, 200, 201], 1, true), Op::Call(87, vec![202], 2, false), Op::Load(3, 204), Op::AssertEq(vec![205, 206, 207], vec![53, 53, 53], Some("aggr: trailing bytes after shape hint".into()))], ctrl: Ctrl::Match(203, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(274, vec![208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(274, vec![208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(275, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Call(275, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(275, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(275, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(276, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(6, vec![]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Call(276, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(7, vec![]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(276, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(8, vec![]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(276, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(9, vec![]) }), (G::from_u64(10), Block { ops: vec![Op::Call(290, vec![181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(10, vec![]) }), (G::from_u64(11), Block { ops: vec![Op::Call(291, vec![181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(11, vec![]) }), (G::from_u64(12), Block { ops: vec![Op::Call(292, vec![181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(12, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 13, auxiliaries: 106, lookups: 33 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_294() -> Function { + Function { body: Block { ops: vec![Op::Call(308, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_295() -> Function { + Function { body: Block { ops: vec![Op::Load(26, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(0), Block { ops: vec![Op::Call(295, vec![26], 1, false), Op::Const(G::from_u64(1)), Op::Add(27, 28)], ctrl: Ctrl::Return(1, vec![29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_296() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(296, vec![3], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 5)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_297() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(297, vec![4], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_298() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(298, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_299() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(299, vec![6], 1, false), Op::Const(G::from_u64(1)), Op::Add(7, 8)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_300() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(300, vec![7], 1, false), Op::Const(G::from_u64(1)), Op::Add(8, 9)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_301() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(301, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Add(11, 12)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_302() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(302, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::Add(12, 13)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_303() -> Function { + Function { body: Block { ops: vec![Op::Call(309, vec![0, 1], 1, false), Op::Load(6, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_304() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_305() -> Function { + Function { body: Block { ops: vec![Op::Call(311, vec![0, 1], 1, false), Op::Load(4, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_306() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(306, vec![11, 1], 1, false), Op::Store(vec![12, 3, 4, 5, 6, 7, 8, 9, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_307() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(307, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_308() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(308, vec![0, 3], 1, false), Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_309() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(309, vec![0, 3], 1, false), Op::Load(6, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_310() -> Function { + Function { body: Block { ops: vec![Op::Call(312, vec![0, 1], 1, false), Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7, 8, 9, 10, 11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_311() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(311, vec![0, 3], 1, false), Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_312() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(312, vec![0, 3], 1, false), Op::Load(10, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21(), expected_function_22(), expected_function_23(), expected_function_24(), expected_function_25(), expected_function_26(), expected_function_27(), expected_function_28(), expected_function_29(), expected_function_30(), expected_function_31(), expected_function_32(), expected_function_33(), expected_function_34(), expected_function_35(), expected_function_36(), expected_function_37(), expected_function_38(), expected_function_39(), expected_function_40(), expected_function_41(), expected_function_42(), expected_function_43(), expected_function_44(), expected_function_45(), expected_function_46(), expected_function_47(), expected_function_48(), expected_function_49(), expected_function_50(), expected_function_51(), expected_function_52(), expected_function_53(), expected_function_54(), expected_function_55(), expected_function_56(), expected_function_57(), expected_function_58(), expected_function_59(), expected_function_60(), expected_function_61(), expected_function_62(), expected_function_63(), expected_function_64(), expected_function_65(), expected_function_66(), expected_function_67(), expected_function_68(), expected_function_69(), expected_function_70(), expected_function_71(), expected_function_72(), expected_function_73(), expected_function_74(), expected_function_75(), expected_function_76(), expected_function_77(), expected_function_78(), expected_function_79(), expected_function_80(), expected_function_81(), expected_function_82(), expected_function_83(), expected_function_84(), expected_function_85(), expected_function_86(), expected_function_87(), expected_function_88(), expected_function_89(), expected_function_90(), expected_function_91(), expected_function_92(), expected_function_93(), expected_function_94(), expected_function_95(), expected_function_96(), expected_function_97(), expected_function_98(), expected_function_99(), expected_function_100(), expected_function_101(), expected_function_102(), expected_function_103(), expected_function_104(), expected_function_105(), expected_function_106(), expected_function_107(), expected_function_108(), expected_function_109(), expected_function_110(), expected_function_111(), expected_function_112(), expected_function_113(), expected_function_114(), expected_function_115(), expected_function_116(), expected_function_117(), expected_function_118(), expected_function_119(), expected_function_120(), expected_function_121(), expected_function_122(), expected_function_123(), expected_function_124(), expected_function_125(), expected_function_126(), expected_function_127(), expected_function_128(), expected_function_129(), expected_function_130(), expected_function_131(), expected_function_132(), expected_function_133(), expected_function_134(), expected_function_135(), expected_function_136(), expected_function_137(), expected_function_138(), expected_function_139(), expected_function_140(), expected_function_141(), expected_function_142(), expected_function_143(), expected_function_144(), expected_function_145(), expected_function_146(), expected_function_147(), expected_function_148(), expected_function_149(), expected_function_150(), expected_function_151(), expected_function_152(), expected_function_153(), expected_function_154(), expected_function_155(), expected_function_156(), expected_function_157(), expected_function_158(), expected_function_159(), expected_function_160(), expected_function_161(), expected_function_162(), expected_function_163(), expected_function_164(), expected_function_165(), expected_function_166(), expected_function_167(), expected_function_168(), expected_function_169(), expected_function_170(), expected_function_171(), expected_function_172(), expected_function_173(), expected_function_174(), expected_function_175(), expected_function_176(), expected_function_177(), expected_function_178(), expected_function_179(), expected_function_180(), expected_function_181(), expected_function_182(), expected_function_183(), expected_function_184(), expected_function_185(), expected_function_186(), expected_function_187(), expected_function_188(), expected_function_189(), expected_function_190(), expected_function_191(), expected_function_192(), expected_function_193(), expected_function_194(), expected_function_195(), expected_function_196(), expected_function_197(), expected_function_198(), expected_function_199(), expected_function_200(), expected_function_201(), expected_function_202(), expected_function_203(), expected_function_204(), expected_function_205(), expected_function_206(), expected_function_207(), expected_function_208(), expected_function_209(), expected_function_210(), expected_function_211(), expected_function_212(), expected_function_213(), expected_function_214(), expected_function_215(), expected_function_216(), expected_function_217(), expected_function_218(), expected_function_219(), expected_function_220(), expected_function_221(), expected_function_222(), expected_function_223(), expected_function_224(), expected_function_225(), expected_function_226(), expected_function_227(), expected_function_228(), expected_function_229(), expected_function_230(), expected_function_231(), expected_function_232(), expected_function_233(), expected_function_234(), expected_function_235(), expected_function_236(), expected_function_237(), expected_function_238(), expected_function_239(), expected_function_240(), expected_function_241(), expected_function_242(), expected_function_243(), expected_function_244(), expected_function_245(), expected_function_246(), expected_function_247(), expected_function_248(), expected_function_249(), expected_function_250(), expected_function_251(), expected_function_252(), expected_function_253(), expected_function_254(), expected_function_255(), expected_function_256(), expected_function_257(), expected_function_258(), expected_function_259(), expected_function_260(), expected_function_261(), expected_function_262(), expected_function_263(), expected_function_264(), expected_function_265(), expected_function_266(), expected_function_267(), expected_function_268(), expected_function_269(), expected_function_270(), expected_function_271(), expected_function_272(), expected_function_273(), expected_function_274(), expected_function_275(), expected_function_276(), expected_function_277(), expected_function_278(), expected_function_279(), expected_function_280(), expected_function_281(), expected_function_282(), expected_function_283(), expected_function_284(), expected_function_285(), expected_function_286(), expected_function_287(), expected_function_288(), expected_function_289(), expected_function_290(), expected_function_291(), expected_function_292(), expected_function_293(), expected_function_294(), expected_function_295(), expected_function_296(), expected_function_297(), expected_function_298(), expected_function_299(), expected_function_300(), expected_function_301(), expected_function_302(), expected_function_303(), expected_function_304(), expected_function_305(), expected_function_306(), expected_function_307(), expected_function_308(), expected_function_309(), expected_function_310(), expected_function_311(), expected_function_312()], memory_sizes: vec![3, 4, 5, 6, 7, 8, 10, 11, 26, 32, 34], circuits: vec![Circuit { members: vec![0, 4, 13, 14, 99, 122, 123, 124, 125, 167, 183, 191], layout: FunctionLayout { input_size: 8, selectors: 40, auxiliaries: 20, lookups: 7 } }, Circuit { members: vec![1, 2, 247, 254, 256, 257, 265, 266, 268, 269, 270, 273], layout: FunctionLayout { input_size: 28, selectors: 40, auxiliaries: 73, lookups: 10 } }, Circuit { members: vec![12], layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![26, 40, 91, 93, 100, 144, 185, 192, 206, 207, 208, 302], layout: FunctionLayout { input_size: 3, selectors: 25, auxiliaries: 18, lookups: 6 } }, Circuit { members: vec![27, 76, 77, 92, 128, 139, 151, 160, 168, 176, 177, 180, 197], layout: FunctionLayout { input_size: 44, selectors: 26, auxiliaries: 137, lookups: 14 } }, Circuit { members: vec![28, 48, 56, 59, 61, 75, 111, 140, 158, 173, 179, 204, 240, 300, 306], layout: FunctionLayout { input_size: 9, selectors: 27, auxiliaries: 98, lookups: 32 } }, Circuit { members: vec![31, 309], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 3 } }, Circuit { members: vec![35, 45, 49, 108, 127, 141, 152, 154, 162, 163, 166, 178], layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![36, 296], layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![37], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 } }, Circuit { members: vec![38, 46, 47, 80, 90, 113, 121, 130, 135, 136, 174, 298], layout: FunctionLayout { input_size: 2, selectors: 23, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![39, 195], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 23, lookups: 3 } }, Circuit { members: vec![41, 52, 105, 119, 131, 138, 142, 157, 161, 164, 181, 186, 188, 200, 307], layout: FunctionLayout { input_size: 8, selectors: 31, auxiliaries: 42, lookups: 9 } }, Circuit { members: vec![43, 97], layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![62], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 } }, Circuit { members: vec![65], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 } }, Circuit { members: vec![68], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 } }, Circuit { members: vec![70], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 } }, Circuit { members: vec![78], layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![79, 81, 82, 103, 175, 203, 241, 242], layout: FunctionLayout { input_size: 20, selectors: 27, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![86], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![87], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![88], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![89], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![95, 104, 145, 153, 159, 165, 201, 205, 238, 243, 299], layout: FunctionLayout { input_size: 25, selectors: 38, auxiliaries: 46, lookups: 20 } }, Circuit { members: vec![96], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 } }, Circuit { members: vec![112, 190, 304], layout: FunctionLayout { input_size: 6, selectors: 5, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![114], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 } }, Circuit { members: vec![115, 126, 134], layout: FunctionLayout { input_size: 4, selectors: 10, auxiliaries: 34, lookups: 13 } }, Circuit { members: vec![116], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 } }, Circuit { members: vec![117], layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 } }, Circuit { members: vec![120, 129, 305, 311], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![133], layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 } }, Circuit { members: vec![143], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 } }, Circuit { members: vec![146], layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 } }, Circuit { members: vec![147, 148, 149, 150, 194, 196], layout: FunctionLayout { input_size: 19, selectors: 12, auxiliaries: 14, lookups: 7 } }, Circuit { members: vec![171], layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![193], layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 } }, Circuit { members: vec![209], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![210], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![211], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![212], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 } }, Circuit { members: vec![213], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![214], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![215], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 } }, Circuit { members: vec![216], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 } }, Circuit { members: vec![217], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 } }, Circuit { members: vec![218], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![219], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 } }, Circuit { members: vec![220], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![221], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 } }, Circuit { members: vec![222], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 } }, Circuit { members: vec![223], layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 } }, Circuit { members: vec![224], layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 } }, Circuit { members: vec![225], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![226], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![227], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 } }, Circuit { members: vec![228], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 } }, Circuit { members: vec![229], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![230], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![231], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 } }, Circuit { members: vec![232], layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 } }, Circuit { members: vec![233], layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 } }, Circuit { members: vec![234], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![235], layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 } }, Circuit { members: vec![244, 245, 248, 249, 250, 251, 252, 253, 255, 258, 259, 260, 264, 267, 310, 312], layout: FunctionLayout { input_size: 4, selectors: 37, auxiliaries: 13, lookups: 7 } }, Circuit { members: vec![261, 262, 263, 271, 272, 274, 275, 276], layout: FunctionLayout { input_size: 36, selectors: 16, auxiliaries: 143, lookups: 30 } }, Circuit { members: vec![277], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 72, lookups: 36 } }, Circuit { members: vec![278], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 66, lookups: 34 } }, Circuit { members: vec![279], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![280], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![281], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 12 } }, Circuit { members: vec![282], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 4 } }, Circuit { members: vec![283], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 11 } }, Circuit { members: vec![284], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 4 } }, Circuit { members: vec![285], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 33, lookups: 10 } }, Circuit { members: vec![286], layout: FunctionLayout { input_size: 14, selectors: 3, auxiliaries: 8, lookups: 3 } }, Circuit { members: vec![287], layout: FunctionLayout { input_size: 23, selectors: 2, auxiliaries: 38, lookups: 5 } }, Circuit { members: vec![288], layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 60, lookups: 8 } }, Circuit { members: vec![289], layout: FunctionLayout { input_size: 27, selectors: 1, auxiliaries: 29, lookups: 4 } }, Circuit { members: vec![290], layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 55, lookups: 11 } }, Circuit { members: vec![291], layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 71, lookups: 12 } }, Circuit { members: vec![292], layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 64, lookups: 18 } }, Circuit { members: vec![293], layout: FunctionLayout { input_size: 16, selectors: 13, auxiliaries: 106, lookups: 33 } }, Circuit { members: vec![294, 297, 308], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![295], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 } }, Circuit { members: vec![301], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![303], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [192, 114, 108, 80, 224, 251, 146, 62, 231, 56, 127, 105, 147, 26, 68, 117, 241, 169, 63, 124, 221, 174, 220, 212, 61, 234, 92, 95, 60, 118, 170, 102], complete: false, expected: expected_program, functions: &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_86, pack: pack_86, pack_typed: pack_86_typed, pack_checked: pack_86_checked, write: |seed, offsets, row| { write_86(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, output_size: 1, seed_words: 201, schema: &SCHEMA_117, pack: pack_117, pack_typed: pack_117_typed, pack_checked: pack_117_checked, write: |seed, offsets, row| { write_117(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_220, pack: pack_220, pack_typed: pack_220_typed, pack_checked: pack_220_checked, write: write_220 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 1, seed_words: 25, schema: &SCHEMA_230, pack: pack_230, pack_typed: pack_230_typed, pack_checked: pack_230_checked, write: |seed, offsets, row| { write_230(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +] }; diff --git a/crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs b/crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs new file mode 100644 index 000000000..4657aabfd --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs @@ -0,0 +1,325 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_ix_aggr_contract() -> *const u8; + fn aiur_trace_ix_aggr_schema() -> *const u8; + pub(super) fn aiur_trace_ix_aggr_86(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ix_aggr_117(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ix_aggr_220(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ix_aggr_230(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([192, 114, 108, 80, 224, 251, 146, 62, 231, 56, 127, 105, 147, 26, 68, 117, 241, 169, 63, 124, 221, 174, 220, 212, 61, 234, 92, 95, 60, 118, 170, 102], aiur_trace_ix_aggr_contract, aiur_trace_ix_aggr_schema, &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_86), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_117), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_220), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_230), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +], &[3, 67, 68, 0, 9, 0, 0, 0, 0, 0, 0, 0, 17, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 18, 12, 0, 0, 12, 0, 0, 0, 8, 6, 15, 6, 24, 6, 43, 0, 8, 0, 10, 6, 8, 6, 8, 0, 0, 8, 0, 0, 0, 12, 0, 0, 14, 0, 6, 52, 0, 0, 20, 0, 0, 17, 0, 31, 0, 0, 0, 0, 40, 170, 137, 13, 194, 5, 146, 158, 0, 0, 0, 162, 5, 4, 6, 6, 10, 18, 11, 0, 43, 15, 8, 0, 12, 5, 0, 0, 69, 8, 8, 0, 0, 10, 0, 0, 100, 5, 7, 22, 22, 27, 201, 0, 43, 8, 6, 18, 18, 19, 15, 33, 9, 22, 8, 7, 13, 0, 27, 10, 8, 8, 0, 8, 17, 42, 8, 8, 21, 11, 3, 19, 17, 19, 20, 23, 22, 8, 6, 11, 0, 0, 16, 41, 54, 36, 10, 10, 11, 9, 30, 9, 11, 23, 0, 0, 18, 0, 43, 8, 76, 23, 23, 8, 20, 13, 6, 0, 15, 0, 6, 3, 0, 3, 0, 7, 5, 14, 24, 29, 9, 33, 81, 0, 0, 12, 2, 0, 94, 16, 15, 6, 19, 12, 4, 6, 10, 12, 11, 6, 19, 68, 48, 10, 25, 11, 78, 12, 23, 2, 7, 6, 2, 42, 4, 25, 78, 119, 59, 10, 32, 0, 0, 10, 0, 15, 99, 67, 34, 8, 6, 0, 67, 9, 9, 8, 12, 10, 4, 47, 4, 10, 15, 10, 9, 15, 11, 49, 14, 6, 16, 49, 11, 11, 17, 8, 159, 40, 62, 44, 110, 109, 73, 67, 8, 8, 42, 11, 22, 16, 35, 21, 60, 68, 56, 74, 100, 93, 122, 7, 29, 6, 7, 8, 9, 10, 13, 14, 10, 5, 8, 15, 8, 7, 10, 14, 8, 14], &[16, 528, 536, 0, 72, 0, 0, 0, 0, 0, 0, 0, 136, 72, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 112, 88, 0, 0, 96, 0, 0, 0, 56, 48, 112, 48, 184, 48, 336, 0, 56, 0, 72, 48, 56, 48, 56, 0, 0, 56, 0, 0, 0, 80, 0, 0, 96, 0, 48, 352, 0, 0, 136, 0, 0, 128, 0, 176, 0, 0, 0, 0, 296, 432, 840, 80, 848, 40, 416, 272, 0, 0, 0, 176, 32, 32, 40, 40, 64, 112, 88, 0, 312, 96, 48, 0, 72, 40, 0, 0, 304, 48, 48, 0, 0, 64, 0, 0, 120, 32, 40, 136, 128, 128, 544, 0, 312, 40, 40, 96, 112, 120, 72, 176, 56, 120, 48, 48, 96, 0, 192, 64, 48, 48, 0, 48, 120, 280, 64, 56, 144, 72, 24, 128, 112, 144, 144, 168, 160, 56, 32, 80, 0, 0, 120, 224, 336, 216, 56, 64, 64, 48, 160, 56, 64, 112, 0, 0, 112, 0, 312, 48, 464, 168, 168, 48, 104, 96, 40, 0, 104, 0, 48, 24, 0, 24, 0, 56, 40, 88, 192, 224, 72, 256, 632, 0, 0, 88, 16, 0, 616, 120, 104, 32, 120, 64, 32, 40, 64, 72, 64, 40, 128, 432, 344, 48, 160, 40, 552, 72, 168, 16, 32, 40, 16, 232, 24, 88, 576, 688, 320, 64, 184, 0, 0, 56, 0, 104, 440, 408, 272, 40, 32, 0, 528, 40, 56, 40, 56, 56, 24, 304, 24, 40, 56, 48, 40, 56, 64, 312, 48, 32, 48, 360, 88, 88, 136, 32, 784, 200, 432, 352, 776, 768, 416, 408, 48, 48, 272, 56, 136, 112, 200, 144, 344, 512, 440, 408, 736, 656, 784, 48, 152, 40, 48, 48, 64, 72, 96, 96, 72, 32, 56, 104, 48, 48, 72, 104, 56, 104]) }; diff --git a/crates/aiur/src/trace_codegen/programs/ixvm.rs b/crates/aiur/src/trace_codegen/programs/ixvm.rs new file mode 100644 index 000000000..3442aaa7e --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ixvm.rs @@ -0,0 +1,5313 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_16(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_16_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_16_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn write_16(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let op_0 = Bytes2::add(&v_0, &v_8); let [v_16, v_17]: [G; 2] = [op_0.0, op_0.1]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); let op_1 = Bytes2::add(&v_1, &v_9); let [v_18, v_19]: [G; 2] = [op_1.0, op_1.1]; row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); let op_2 = Bytes2::add(&v_18, &v_17); let [v_20, v_21]: [G; 2] = [op_2.0, op_2.1]; row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); let [v_22]: [G; 1] = [v_19 + v_21]; let op_4 = Bytes2::add(&v_2, &v_10); let [v_23, v_24]: [G; 2] = [op_4.0, op_4.1]; row[offsets.auxiliaries + 4] = v_23.as_canonical_u64(); let op_5 = Bytes2::add(&v_23, &v_22); let [v_25, v_26]: [G; 2] = [op_5.0, op_5.1]; row[offsets.auxiliaries + 5] = v_25.as_canonical_u64(); let [v_27]: [G; 1] = [v_24 + v_26]; let op_7 = Bytes2::add(&v_3, &v_11); let [v_28, v_29]: [G; 2] = [op_7.0, op_7.1]; row[offsets.auxiliaries + 6] = v_28.as_canonical_u64(); let op_8 = Bytes2::add(&v_28, &v_27); let [v_30, v_31]: [G; 2] = [op_8.0, op_8.1]; row[offsets.auxiliaries + 7] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = [v_29 + v_31]; let op_10 = Bytes2::add(&v_4, &v_12); let [v_33, v_34]: [G; 2] = [op_10.0, op_10.1]; row[offsets.auxiliaries + 8] = v_33.as_canonical_u64(); let op_11 = Bytes2::add(&v_33, &v_32); let [v_35, v_36]: [G; 2] = [op_11.0, op_11.1]; row[offsets.auxiliaries + 9] = v_35.as_canonical_u64(); let [v_37]: [G; 1] = [v_34 + v_36]; let op_13 = Bytes2::add(&v_5, &v_13); let [v_38, v_39]: [G; 2] = [op_13.0, op_13.1]; row[offsets.auxiliaries + 10] = v_38.as_canonical_u64(); let op_14 = Bytes2::add(&v_38, &v_37); let [v_40, v_41]: [G; 2] = [op_14.0, op_14.1]; row[offsets.auxiliaries + 11] = v_40.as_canonical_u64(); let [v_42]: [G; 1] = [v_39 + v_41]; let op_16 = Bytes2::add(&v_6, &v_14); let [v_43, v_44]: [G; 2] = [op_16.0, op_16.1]; row[offsets.auxiliaries + 12] = v_43.as_canonical_u64(); let op_17 = Bytes2::add(&v_43, &v_42); let [v_45, v_46]: [G; 2] = [op_17.0, op_17.1]; row[offsets.auxiliaries + 13] = v_45.as_canonical_u64(); let [v_47]: [G; 1] = [v_44 + v_46]; let op_19 = Bytes2::add(&v_7, &v_15); let [v_48, v_49]: [G; 2] = [op_19.0, op_19.1]; row[offsets.auxiliaries + 14] = v_48.as_canonical_u64(); let op_20 = Bytes2::add(&v_48, &v_47); let [v_50, v_51]: [G; 2] = [op_20.0, op_20.1]; row[offsets.auxiliaries + 15] = v_50.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_16: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], bytes: 24 }; + +fn pack_27(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(0, v_0)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.returned::<1>(1)?; seed[11] = v_10.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(3, &[v_11, v_8, v_1])?; seed[11] = v_12.as_canonical_u64(); match v_2.as_canonical_u64() { 63u64 => { let [v_13]: [G; 1] = context.returned::<1>(4)?; seed[12] = v_13.as_canonical_u64(); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(8)?; seed[12] = v_17.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(27, v_7)) }, } } + +fn pack_27_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(73, v_7); seed.full(32, v_8); seed.u32(68, v_9); match v_7.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.returned::<1>(1)?; seed.full(40, v_10); Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(3, &[v_11, v_8, v_1])?; seed.full(40, v_12); match v_2.as_canonical_u64() { 63u64 => { let [v_13]: [G; 1] = context.returned::<1>(4)?; seed.full(48, v_13); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(8)?; seed.full(48, v_17); Ok(()) }, } }, _ => { Err(no_match(27, v_7)) }, } } + +fn pack_27_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(0, v_0)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.check_returned::<1>(1, 30, &[v_1, v_2, v_3, v_4, v_5, v_6])?; seed[11] = v_10.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(3, &[v_11, v_8, v_1])?; seed[11] = v_12.as_canonical_u64(); match v_2.as_canonical_u64() { 63u64 => { let [v_13]: [G; 1] = context.check_returned::<1>(4, 31, &[v_9, v_12, v_3, v_4, v_5, v_6])?; seed[12] = v_13.as_canonical_u64(); Ok(()) }, _ => { let [v_14]: [G; 1] = [G::from_u64(1)]; let [v_15]: [G; 1] = [v_2 + v_14]; let [v_16]: [G; 1] = [v_3 + v_14]; let [v_17]: [G; 1] = context.check_returned::<1>(8, 27, &[v_9, v_12, v_15, v_16, v_4, v_5, v_6])?; seed[12] = v_17.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(27, v_7)) }, } } + +fn write_27(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 4] = v_10.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); match v_2.as_canonical_u64() { 63u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 5] = (v_2 - G::from_u64(63)).inverse().as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 6] = v_17.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(27, v_7)) }, } } + +static SCHEMA_27: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 56, 8, 72, 16, 60, 64, 24, 73, 32, 68, 40, 48], bytes: 80 }; + +fn pack_28(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); seed[97] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed[131] = v_130.as_canonical_u64(); seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed[143] = v_142.as_canonical_u64(); seed[144] = v_143.as_canonical_u64(); seed[145] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed[146] = v_145.as_canonical_u64(); seed[147] = v_146.as_canonical_u64(); seed[148] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed[149] = v_148.as_canonical_u64(); seed[150] = v_149.as_canonical_u64(); seed[151] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed[152] = v_151.as_canonical_u64(); seed[153] = v_152.as_canonical_u64(); seed[154] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed[155] = v_154.as_canonical_u64(); seed[156] = v_155.as_canonical_u64(); seed[157] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed[158] = v_157.as_canonical_u64(); seed[159] = v_158.as_canonical_u64(); seed[160] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed[161] = v_160.as_canonical_u64(); seed[162] = v_161.as_canonical_u64(); seed[163] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed[164] = v_163.as_canonical_u64(); seed[165] = v_164.as_canonical_u64(); seed[166] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed[167] = v_166.as_canonical_u64(); seed[168] = v_167.as_canonical_u64(); seed[169] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed[170] = v_169.as_canonical_u64(); seed[171] = v_170.as_canonical_u64(); seed[172] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed[173] = v_172.as_canonical_u64(); seed[174] = v_173.as_canonical_u64(); seed[175] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed[176] = v_175.as_canonical_u64(); seed[177] = v_176.as_canonical_u64(); seed[178] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed[179] = v_178.as_canonical_u64(); seed[180] = v_179.as_canonical_u64(); seed[181] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed[182] = v_181.as_canonical_u64(); seed[183] = v_182.as_canonical_u64(); seed[184] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed[185] = v_184.as_canonical_u64(); seed[186] = v_185.as_canonical_u64(); seed[187] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed[188] = v_187.as_canonical_u64(); seed[189] = v_188.as_canonical_u64(); seed[190] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed[191] = v_190.as_canonical_u64(); seed[192] = v_191.as_canonical_u64(); seed[193] = v_192.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(28, v_187)) }, } }, _ => { Err(no_match(28, v_184)) }, } }, _ => { Err(no_match(28, v_181)) }, } }, _ => { Err(no_match(28, v_178)) }, } }, _ => { Err(no_match(28, v_175)) }, } }, _ => { Err(no_match(28, v_172)) }, } }, _ => { Err(no_match(28, v_169)) }, } }, _ => { Err(no_match(28, v_166)) }, } }, _ => { Err(no_match(28, v_163)) }, } }, _ => { Err(no_match(28, v_160)) }, } }, _ => { Err(no_match(28, v_157)) }, } }, _ => { Err(no_match(28, v_154)) }, } }, _ => { Err(no_match(28, v_151)) }, } }, _ => { Err(no_match(28, v_148)) }, } }, _ => { Err(no_match(28, v_145)) }, } }, _ => { Err(no_match(28, v_142)) }, } }, _ => { Err(no_match(28, v_139)) }, } }, _ => { Err(no_match(28, v_136)) }, } }, _ => { Err(no_match(28, v_133)) }, } }, _ => { Err(no_match(28, v_130)) }, } }, _ => { Err(no_match(28, v_127)) }, } }, _ => { Err(no_match(28, v_124)) }, } }, _ => { Err(no_match(28, v_121)) }, } }, _ => { Err(no_match(28, v_118)) }, } }, _ => { Err(no_match(28, v_115)) }, } }, _ => { Err(no_match(28, v_112)) }, } }, _ => { Err(no_match(28, v_109)) }, } }, _ => { Err(no_match(28, v_106)) }, } }, _ => { Err(no_match(28, v_103)) }, } }, _ => { Err(no_match(28, v_100)) }, } }, _ => { Err(no_match(28, v_97)) }, } }, _ => { Err(no_match(28, v_94)) }, } }, _ => { Err(no_match(28, v_91)) }, } }, _ => { Err(no_match(28, v_88)) }, } }, _ => { Err(no_match(28, v_85)) }, } }, _ => { Err(no_match(28, v_82)) }, } }, _ => { Err(no_match(28, v_79)) }, } }, _ => { Err(no_match(28, v_76)) }, } }, _ => { Err(no_match(28, v_73)) }, } }, _ => { Err(no_match(28, v_70)) }, } }, _ => { Err(no_match(28, v_67)) }, } }, _ => { Err(no_match(28, v_64)) }, } }, _ => { Err(no_match(28, v_61)) }, } }, _ => { Err(no_match(28, v_58)) }, } }, _ => { Err(no_match(28, v_55)) }, } }, _ => { Err(no_match(28, v_52)) }, } }, _ => { Err(no_match(28, v_49)) }, } }, _ => { Err(no_match(28, v_46)) }, } }, _ => { Err(no_match(28, v_43)) }, } }, _ => { Err(no_match(28, v_40)) }, } }, _ => { Err(no_match(28, v_37)) }, } }, _ => { Err(no_match(28, v_34)) }, } }, _ => { Err(no_match(28, v_31)) }, } }, _ => { Err(no_match(28, v_28)) }, } }, _ => { Err(no_match(28, v_25)) }, } }, _ => { Err(no_match(28, v_22)) }, } }, _ => { Err(no_match(28, v_19)) }, } }, _ => { Err(no_match(28, v_16)) }, } }, _ => { Err(no_match(28, v_13)) }, } }, _ => { Err(no_match(28, v_10)) }, } }, _ => { Err(no_match(28, v_7)) }, } }, _ => { Err(no_match(28, v_4)) }, } }, _ => { Err(no_match(28, v_1)) }, } } + +fn pack_28_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(784, v_1); seed.full(8, v_2); seed.u32(532, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed.u8(785, v_4); seed.full(16, v_5); seed.u32(536, v_6); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed.u8(786, v_7); seed.full(24, v_8); seed.u32(540, v_9); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed.u8(787, v_10); seed.full(32, v_11); seed.u32(544, v_12); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed.u8(788, v_13); seed.full(40, v_14); seed.u32(548, v_15); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed.u8(789, v_16); seed.full(48, v_17); seed.u32(552, v_18); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed.u8(790, v_19); seed.full(56, v_20); seed.u32(556, v_21); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed.u8(791, v_22); seed.full(64, v_23); seed.u32(560, v_24); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed.u8(792, v_25); seed.full(72, v_26); seed.u32(564, v_27); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed.u8(793, v_28); seed.full(80, v_29); seed.u32(568, v_30); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed.u8(794, v_31); seed.full(88, v_32); seed.u32(572, v_33); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed.u8(795, v_34); seed.full(96, v_35); seed.u32(576, v_36); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed.u8(796, v_37); seed.full(104, v_38); seed.u32(580, v_39); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed.u8(797, v_40); seed.full(112, v_41); seed.u32(584, v_42); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed.u8(798, v_43); seed.full(120, v_44); seed.u32(588, v_45); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed.u8(799, v_46); seed.full(128, v_47); seed.u32(592, v_48); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed.u8(800, v_49); seed.full(136, v_50); seed.u32(596, v_51); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed.u8(801, v_52); seed.full(144, v_53); seed.u32(600, v_54); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed.u8(802, v_55); seed.full(152, v_56); seed.u32(604, v_57); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed.u8(803, v_58); seed.full(160, v_59); seed.u32(608, v_60); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed.u8(804, v_61); seed.full(168, v_62); seed.u32(612, v_63); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed.u8(805, v_64); seed.full(176, v_65); seed.u32(616, v_66); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed.u8(806, v_67); seed.full(184, v_68); seed.u32(620, v_69); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed.u8(807, v_70); seed.full(192, v_71); seed.u32(624, v_72); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed.u8(808, v_73); seed.full(200, v_74); seed.u32(628, v_75); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed.u8(809, v_76); seed.full(208, v_77); seed.u32(632, v_78); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed.u8(810, v_79); seed.full(216, v_80); seed.u32(636, v_81); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed.u8(811, v_82); seed.full(224, v_83); seed.u32(640, v_84); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed.u8(812, v_85); seed.full(232, v_86); seed.u32(644, v_87); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed.u8(813, v_88); seed.full(240, v_89); seed.u32(648, v_90); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed.u8(814, v_91); seed.full(248, v_92); seed.u32(652, v_93); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed.u8(815, v_94); seed.full(256, v_95); seed.u32(656, v_96); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed.u8(816, v_97); seed.full(264, v_98); seed.u32(660, v_99); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed.u8(817, v_100); seed.full(272, v_101); seed.u32(664, v_102); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed.u8(818, v_103); seed.full(280, v_104); seed.u32(668, v_105); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed.u8(819, v_106); seed.full(288, v_107); seed.u32(672, v_108); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed.u8(820, v_109); seed.full(296, v_110); seed.u32(676, v_111); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed.u8(821, v_112); seed.full(304, v_113); seed.u32(680, v_114); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed.u8(822, v_115); seed.full(312, v_116); seed.u32(684, v_117); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed.u8(823, v_118); seed.full(320, v_119); seed.u32(688, v_120); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed.u8(824, v_121); seed.full(328, v_122); seed.u32(692, v_123); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed.u8(825, v_124); seed.full(336, v_125); seed.u32(696, v_126); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed.u8(826, v_127); seed.full(344, v_128); seed.u32(700, v_129); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed.u8(827, v_130); seed.full(352, v_131); seed.u32(704, v_132); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed.u8(828, v_133); seed.full(360, v_134); seed.u32(708, v_135); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed.u8(829, v_136); seed.full(368, v_137); seed.u32(712, v_138); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed.u8(830, v_139); seed.full(376, v_140); seed.u32(716, v_141); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed.u8(831, v_142); seed.full(384, v_143); seed.u32(720, v_144); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed.u8(832, v_145); seed.full(392, v_146); seed.u32(724, v_147); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed.u8(833, v_148); seed.full(400, v_149); seed.u32(728, v_150); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed.u8(834, v_151); seed.full(408, v_152); seed.u32(732, v_153); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed.u8(835, v_154); seed.full(416, v_155); seed.u32(736, v_156); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed.u8(836, v_157); seed.full(424, v_158); seed.u32(740, v_159); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed.u8(837, v_160); seed.full(432, v_161); seed.u32(744, v_162); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed.u8(838, v_163); seed.full(440, v_164); seed.u32(748, v_165); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed.u8(839, v_166); seed.full(448, v_167); seed.u32(752, v_168); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed.u8(840, v_169); seed.full(456, v_170); seed.u32(756, v_171); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed.u8(841, v_172); seed.full(464, v_173); seed.u32(760, v_174); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed.u8(842, v_175); seed.full(472, v_176); seed.u32(764, v_177); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed.u8(843, v_178); seed.full(480, v_179); seed.u32(768, v_180); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed.u8(844, v_181); seed.full(488, v_182); seed.u32(772, v_183); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed.u8(845, v_184); seed.full(496, v_185); seed.u32(776, v_186); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed.u8(846, v_187); seed.full(504, v_188); seed.u32(780, v_189); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed.u8(847, v_190); seed.full(512, v_191); seed.full(520, v_192); Ok(()) }, _ => { Err(no_match(28, v_187)) }, } }, _ => { Err(no_match(28, v_184)) }, } }, _ => { Err(no_match(28, v_181)) }, } }, _ => { Err(no_match(28, v_178)) }, } }, _ => { Err(no_match(28, v_175)) }, } }, _ => { Err(no_match(28, v_172)) }, } }, _ => { Err(no_match(28, v_169)) }, } }, _ => { Err(no_match(28, v_166)) }, } }, _ => { Err(no_match(28, v_163)) }, } }, _ => { Err(no_match(28, v_160)) }, } }, _ => { Err(no_match(28, v_157)) }, } }, _ => { Err(no_match(28, v_154)) }, } }, _ => { Err(no_match(28, v_151)) }, } }, _ => { Err(no_match(28, v_148)) }, } }, _ => { Err(no_match(28, v_145)) }, } }, _ => { Err(no_match(28, v_142)) }, } }, _ => { Err(no_match(28, v_139)) }, } }, _ => { Err(no_match(28, v_136)) }, } }, _ => { Err(no_match(28, v_133)) }, } }, _ => { Err(no_match(28, v_130)) }, } }, _ => { Err(no_match(28, v_127)) }, } }, _ => { Err(no_match(28, v_124)) }, } }, _ => { Err(no_match(28, v_121)) }, } }, _ => { Err(no_match(28, v_118)) }, } }, _ => { Err(no_match(28, v_115)) }, } }, _ => { Err(no_match(28, v_112)) }, } }, _ => { Err(no_match(28, v_109)) }, } }, _ => { Err(no_match(28, v_106)) }, } }, _ => { Err(no_match(28, v_103)) }, } }, _ => { Err(no_match(28, v_100)) }, } }, _ => { Err(no_match(28, v_97)) }, } }, _ => { Err(no_match(28, v_94)) }, } }, _ => { Err(no_match(28, v_91)) }, } }, _ => { Err(no_match(28, v_88)) }, } }, _ => { Err(no_match(28, v_85)) }, } }, _ => { Err(no_match(28, v_82)) }, } }, _ => { Err(no_match(28, v_79)) }, } }, _ => { Err(no_match(28, v_76)) }, } }, _ => { Err(no_match(28, v_73)) }, } }, _ => { Err(no_match(28, v_70)) }, } }, _ => { Err(no_match(28, v_67)) }, } }, _ => { Err(no_match(28, v_64)) }, } }, _ => { Err(no_match(28, v_61)) }, } }, _ => { Err(no_match(28, v_58)) }, } }, _ => { Err(no_match(28, v_55)) }, } }, _ => { Err(no_match(28, v_52)) }, } }, _ => { Err(no_match(28, v_49)) }, } }, _ => { Err(no_match(28, v_46)) }, } }, _ => { Err(no_match(28, v_43)) }, } }, _ => { Err(no_match(28, v_40)) }, } }, _ => { Err(no_match(28, v_37)) }, } }, _ => { Err(no_match(28, v_34)) }, } }, _ => { Err(no_match(28, v_31)) }, } }, _ => { Err(no_match(28, v_28)) }, } }, _ => { Err(no_match(28, v_25)) }, } }, _ => { Err(no_match(28, v_22)) }, } }, _ => { Err(no_match(28, v_19)) }, } }, _ => { Err(no_match(28, v_16)) }, } }, _ => { Err(no_match(28, v_13)) }, } }, _ => { Err(no_match(28, v_10)) }, } }, _ => { Err(no_match(28, v_7)) }, } }, _ => { Err(no_match(28, v_4)) }, } }, _ => { Err(no_match(28, v_1)) }, } } + +fn pack_28_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); seed[97] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed[131] = v_130.as_canonical_u64(); seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed[143] = v_142.as_canonical_u64(); seed[144] = v_143.as_canonical_u64(); seed[145] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed[146] = v_145.as_canonical_u64(); seed[147] = v_146.as_canonical_u64(); seed[148] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed[149] = v_148.as_canonical_u64(); seed[150] = v_149.as_canonical_u64(); seed[151] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed[152] = v_151.as_canonical_u64(); seed[153] = v_152.as_canonical_u64(); seed[154] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed[155] = v_154.as_canonical_u64(); seed[156] = v_155.as_canonical_u64(); seed[157] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed[158] = v_157.as_canonical_u64(); seed[159] = v_158.as_canonical_u64(); seed[160] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed[161] = v_160.as_canonical_u64(); seed[162] = v_161.as_canonical_u64(); seed[163] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed[164] = v_163.as_canonical_u64(); seed[165] = v_164.as_canonical_u64(); seed[166] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed[167] = v_166.as_canonical_u64(); seed[168] = v_167.as_canonical_u64(); seed[169] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed[170] = v_169.as_canonical_u64(); seed[171] = v_170.as_canonical_u64(); seed[172] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed[173] = v_172.as_canonical_u64(); seed[174] = v_173.as_canonical_u64(); seed[175] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed[176] = v_175.as_canonical_u64(); seed[177] = v_176.as_canonical_u64(); seed[178] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed[179] = v_178.as_canonical_u64(); seed[180] = v_179.as_canonical_u64(); seed[181] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed[182] = v_181.as_canonical_u64(); seed[183] = v_182.as_canonical_u64(); seed[184] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed[185] = v_184.as_canonical_u64(); seed[186] = v_185.as_canonical_u64(); seed[187] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed[188] = v_187.as_canonical_u64(); seed[189] = v_188.as_canonical_u64(); seed[190] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed[191] = v_190.as_canonical_u64(); seed[192] = v_191.as_canonical_u64(); seed[193] = v_192.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(28, v_187)) }, } }, _ => { Err(no_match(28, v_184)) }, } }, _ => { Err(no_match(28, v_181)) }, } }, _ => { Err(no_match(28, v_178)) }, } }, _ => { Err(no_match(28, v_175)) }, } }, _ => { Err(no_match(28, v_172)) }, } }, _ => { Err(no_match(28, v_169)) }, } }, _ => { Err(no_match(28, v_166)) }, } }, _ => { Err(no_match(28, v_163)) }, } }, _ => { Err(no_match(28, v_160)) }, } }, _ => { Err(no_match(28, v_157)) }, } }, _ => { Err(no_match(28, v_154)) }, } }, _ => { Err(no_match(28, v_151)) }, } }, _ => { Err(no_match(28, v_148)) }, } }, _ => { Err(no_match(28, v_145)) }, } }, _ => { Err(no_match(28, v_142)) }, } }, _ => { Err(no_match(28, v_139)) }, } }, _ => { Err(no_match(28, v_136)) }, } }, _ => { Err(no_match(28, v_133)) }, } }, _ => { Err(no_match(28, v_130)) }, } }, _ => { Err(no_match(28, v_127)) }, } }, _ => { Err(no_match(28, v_124)) }, } }, _ => { Err(no_match(28, v_121)) }, } }, _ => { Err(no_match(28, v_118)) }, } }, _ => { Err(no_match(28, v_115)) }, } }, _ => { Err(no_match(28, v_112)) }, } }, _ => { Err(no_match(28, v_109)) }, } }, _ => { Err(no_match(28, v_106)) }, } }, _ => { Err(no_match(28, v_103)) }, } }, _ => { Err(no_match(28, v_100)) }, } }, _ => { Err(no_match(28, v_97)) }, } }, _ => { Err(no_match(28, v_94)) }, } }, _ => { Err(no_match(28, v_91)) }, } }, _ => { Err(no_match(28, v_88)) }, } }, _ => { Err(no_match(28, v_85)) }, } }, _ => { Err(no_match(28, v_82)) }, } }, _ => { Err(no_match(28, v_79)) }, } }, _ => { Err(no_match(28, v_76)) }, } }, _ => { Err(no_match(28, v_73)) }, } }, _ => { Err(no_match(28, v_70)) }, } }, _ => { Err(no_match(28, v_67)) }, } }, _ => { Err(no_match(28, v_64)) }, } }, _ => { Err(no_match(28, v_61)) }, } }, _ => { Err(no_match(28, v_58)) }, } }, _ => { Err(no_match(28, v_55)) }, } }, _ => { Err(no_match(28, v_52)) }, } }, _ => { Err(no_match(28, v_49)) }, } }, _ => { Err(no_match(28, v_46)) }, } }, _ => { Err(no_match(28, v_43)) }, } }, _ => { Err(no_match(28, v_40)) }, } }, _ => { Err(no_match(28, v_37)) }, } }, _ => { Err(no_match(28, v_34)) }, } }, _ => { Err(no_match(28, v_31)) }, } }, _ => { Err(no_match(28, v_28)) }, } }, _ => { Err(no_match(28, v_25)) }, } }, _ => { Err(no_match(28, v_22)) }, } }, _ => { Err(no_match(28, v_19)) }, } }, _ => { Err(no_match(28, v_16)) }, } }, _ => { Err(no_match(28, v_13)) }, } }, _ => { Err(no_match(28, v_10)) }, } }, _ => { Err(no_match(28, v_7)) }, } }, _ => { Err(no_match(28, v_4)) }, } }, _ => { Err(no_match(28, v_1)) }, } } + +fn write_28(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31])]; row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = [G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = [G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40])]; row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = [G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = [G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = [G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = [G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 49] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = [G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55])]; row[offsets.auxiliaries + 52] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = [G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58])]; row[offsets.auxiliaries + 55] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = [G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 58] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 61] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = [G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67])]; row[offsets.auxiliaries + 64] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = [G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 67] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = [G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73])]; row[offsets.auxiliaries + 70] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = [G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76])]; row[offsets.auxiliaries + 73] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = [G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 76] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = [G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82])]; row[offsets.auxiliaries + 79] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = [G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85])]; row[offsets.auxiliaries + 82] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = [G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88])]; row[offsets.auxiliaries + 85] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = [G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91])]; row[offsets.auxiliaries + 88] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = [G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 91] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 94] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = [G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100])]; row[offsets.auxiliaries + 97] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = [G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103])]; row[offsets.auxiliaries + 100] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = [G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106])]; row[offsets.auxiliaries + 103] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = [G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109])]; row[offsets.auxiliaries + 106] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = [G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 109] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 112] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = [G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118])]; row[offsets.auxiliaries + 115] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = [G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121])]; row[offsets.auxiliaries + 118] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = [G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124])]; row[offsets.auxiliaries + 121] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = [G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127])]; row[offsets.auxiliaries + 124] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = [G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130])]; row[offsets.auxiliaries + 127] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = [G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133])]; row[offsets.auxiliaries + 130] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = [G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136])]; row[offsets.auxiliaries + 133] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = [G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139])]; row[offsets.auxiliaries + 136] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = [G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142])]; row[offsets.auxiliaries + 139] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = [G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 142] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = [G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 145] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151])]; row[offsets.auxiliaries + 148] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = [G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 151] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = [G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157])]; row[offsets.auxiliaries + 154] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = [G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160])]; row[offsets.auxiliaries + 157] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = [G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163])]; row[offsets.auxiliaries + 160] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = [G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166])]; row[offsets.auxiliaries + 163] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = [G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169])]; row[offsets.auxiliaries + 166] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = [G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172])]; row[offsets.auxiliaries + 169] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = [G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175])]; row[offsets.auxiliaries + 172] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = [G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178])]; row[offsets.auxiliaries + 175] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = [G::from_u64(seed[179]), G::from_u64(seed[180]), G::from_u64(seed[181])]; row[offsets.auxiliaries + 178] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = [G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184])]; row[offsets.auxiliaries + 181] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = [G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187])]; row[offsets.auxiliaries + 184] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = [G::from_u64(seed[188]), G::from_u64(seed[189]), G::from_u64(seed[190])]; row[offsets.auxiliaries + 187] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = [G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193])]; row[offsets.auxiliaries + 190] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_192.as_canonical_u64(); match v_190.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(28, v_190)) }, } }, _ => { Err(no_match(28, v_187)) }, } }, _ => { Err(no_match(28, v_184)) }, } }, _ => { Err(no_match(28, v_181)) }, } }, _ => { Err(no_match(28, v_178)) }, } }, _ => { Err(no_match(28, v_175)) }, } }, _ => { Err(no_match(28, v_172)) }, } }, _ => { Err(no_match(28, v_169)) }, } }, _ => { Err(no_match(28, v_166)) }, } }, _ => { Err(no_match(28, v_163)) }, } }, _ => { Err(no_match(28, v_160)) }, } }, _ => { Err(no_match(28, v_157)) }, } }, _ => { Err(no_match(28, v_154)) }, } }, _ => { Err(no_match(28, v_151)) }, } }, _ => { Err(no_match(28, v_148)) }, } }, _ => { Err(no_match(28, v_145)) }, } }, _ => { Err(no_match(28, v_142)) }, } }, _ => { Err(no_match(28, v_139)) }, } }, _ => { Err(no_match(28, v_136)) }, } }, _ => { Err(no_match(28, v_133)) }, } }, _ => { Err(no_match(28, v_130)) }, } }, _ => { Err(no_match(28, v_127)) }, } }, _ => { Err(no_match(28, v_124)) }, } }, _ => { Err(no_match(28, v_121)) }, } }, _ => { Err(no_match(28, v_118)) }, } }, _ => { Err(no_match(28, v_115)) }, } }, _ => { Err(no_match(28, v_112)) }, } }, _ => { Err(no_match(28, v_109)) }, } }, _ => { Err(no_match(28, v_106)) }, } }, _ => { Err(no_match(28, v_103)) }, } }, _ => { Err(no_match(28, v_100)) }, } }, _ => { Err(no_match(28, v_97)) }, } }, _ => { Err(no_match(28, v_94)) }, } }, _ => { Err(no_match(28, v_91)) }, } }, _ => { Err(no_match(28, v_88)) }, } }, _ => { Err(no_match(28, v_85)) }, } }, _ => { Err(no_match(28, v_82)) }, } }, _ => { Err(no_match(28, v_79)) }, } }, _ => { Err(no_match(28, v_76)) }, } }, _ => { Err(no_match(28, v_73)) }, } }, _ => { Err(no_match(28, v_70)) }, } }, _ => { Err(no_match(28, v_67)) }, } }, _ => { Err(no_match(28, v_64)) }, } }, _ => { Err(no_match(28, v_61)) }, } }, _ => { Err(no_match(28, v_58)) }, } }, _ => { Err(no_match(28, v_55)) }, } }, _ => { Err(no_match(28, v_52)) }, } }, _ => { Err(no_match(28, v_49)) }, } }, _ => { Err(no_match(28, v_46)) }, } }, _ => { Err(no_match(28, v_43)) }, } }, _ => { Err(no_match(28, v_40)) }, } }, _ => { Err(no_match(28, v_37)) }, } }, _ => { Err(no_match(28, v_34)) }, } }, _ => { Err(no_match(28, v_31)) }, } }, _ => { Err(no_match(28, v_28)) }, } }, _ => { Err(no_match(28, v_25)) }, } }, _ => { Err(no_match(28, v_22)) }, } }, _ => { Err(no_match(28, v_19)) }, } }, _ => { Err(no_match(28, v_16)) }, } }, _ => { Err(no_match(28, v_13)) }, } }, _ => { Err(no_match(28, v_10)) }, } }, _ => { Err(no_match(28, v_7)) }, } }, _ => { Err(no_match(28, v_4)) }, } }, _ => { Err(no_match(28, v_1)) }, } } + +static SCHEMA_28: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 528, 784, 8, 532, 785, 16, 536, 786, 24, 540, 787, 32, 544, 788, 40, 548, 789, 48, 552, 790, 56, 556, 791, 64, 560, 792, 72, 564, 793, 80, 568, 794, 88, 572, 795, 96, 576, 796, 104, 580, 797, 112, 584, 798, 120, 588, 799, 128, 592, 800, 136, 596, 801, 144, 600, 802, 152, 604, 803, 160, 608, 804, 168, 612, 805, 176, 616, 806, 184, 620, 807, 192, 624, 808, 200, 628, 809, 208, 632, 810, 216, 636, 811, 224, 640, 812, 232, 644, 813, 240, 648, 814, 248, 652, 815, 256, 656, 816, 264, 660, 817, 272, 664, 818, 280, 668, 819, 288, 672, 820, 296, 676, 821, 304, 680, 822, 312, 684, 823, 320, 688, 824, 328, 692, 825, 336, 696, 826, 344, 700, 827, 352, 704, 828, 360, 708, 829, 368, 712, 830, 376, 716, 831, 384, 720, 832, 392, 724, 833, 400, 728, 834, 408, 732, 835, 416, 736, 836, 424, 740, 837, 432, 744, 838, 440, 748, 839, 448, 752, 840, 456, 756, 841, 464, 760, 842, 472, 764, 843, 480, 768, 844, 488, 772, 845, 496, 776, 846, 504, 780, 847, 512, 520], bytes: 848 }; + +fn pack_31(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = context.call::<64>(3, 28, &[v_1])?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); seed[47] = v_49.as_canonical_u64(); seed[48] = v_50.as_canonical_u64(); seed[49] = v_51.as_canonical_u64(); seed[50] = v_52.as_canonical_u64(); seed[51] = v_53.as_canonical_u64(); seed[52] = v_54.as_canonical_u64(); seed[53] = v_55.as_canonical_u64(); seed[54] = v_56.as_canonical_u64(); seed[55] = v_57.as_canonical_u64(); seed[56] = v_58.as_canonical_u64(); seed[57] = v_59.as_canonical_u64(); seed[58] = v_60.as_canonical_u64(); seed[59] = v_61.as_canonical_u64(); seed[60] = v_62.as_canonical_u64(); seed[61] = v_63.as_canonical_u64(); seed[62] = v_64.as_canonical_u64(); seed[63] = v_65.as_canonical_u64(); seed[64] = v_66.as_canonical_u64(); seed[65] = v_67.as_canonical_u64(); seed[66] = v_68.as_canonical_u64(); seed[67] = v_69.as_canonical_u64(); seed[68] = v_70.as_canonical_u64(); seed[69] = v_71.as_canonical_u64(); seed[70] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 795, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed[72] = v_74.as_canonical_u64(); seed[73] = v_75.as_canonical_u64(); seed[74] = v_76.as_canonical_u64(); seed[75] = v_77.as_canonical_u64(); seed[76] = v_78.as_canonical_u64(); seed[77] = v_79.as_canonical_u64(); seed[78] = v_80.as_canonical_u64(); seed[79] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(6, 7, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[80] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_117.as_canonical_u64(); seed[82] = v_118.as_canonical_u64(); seed[83] = v_119.as_canonical_u64(); seed[84] = v_120.as_canonical_u64(); seed[85] = v_121.as_canonical_u64(); seed[86] = v_122.as_canonical_u64(); seed[87] = v_123.as_canonical_u64(); seed[88] = v_124.as_canonical_u64(); seed[89] = v_125.as_canonical_u64(); seed[90] = v_126.as_canonical_u64(); seed[91] = v_127.as_canonical_u64(); seed[92] = v_128.as_canonical_u64(); seed[93] = v_129.as_canonical_u64(); seed[94] = v_130.as_canonical_u64(); seed[95] = v_131.as_canonical_u64(); seed[96] = v_132.as_canonical_u64(); seed[97] = v_133.as_canonical_u64(); seed[98] = v_134.as_canonical_u64(); seed[99] = v_135.as_canonical_u64(); seed[100] = v_136.as_canonical_u64(); seed[101] = v_137.as_canonical_u64(); seed[102] = v_138.as_canonical_u64(); seed[103] = v_139.as_canonical_u64(); seed[104] = v_140.as_canonical_u64(); seed[105] = v_141.as_canonical_u64(); seed[106] = v_142.as_canonical_u64(); seed[107] = v_143.as_canonical_u64(); seed[108] = v_144.as_canonical_u64(); seed[109] = v_145.as_canonical_u64(); seed[110] = v_146.as_canonical_u64(); seed[111] = v_147.as_canonical_u64(); seed[112] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 35, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed[113] = v_151.as_canonical_u64(); seed[114] = v_152.as_canonical_u64(); seed[115] = v_153.as_canonical_u64(); seed[116] = v_154.as_canonical_u64(); seed[117] = v_155.as_canonical_u64(); seed[118] = v_156.as_canonical_u64(); seed[119] = v_157.as_canonical_u64(); seed[120] = v_158.as_canonical_u64(); seed[121] = v_159.as_canonical_u64(); seed[122] = v_160.as_canonical_u64(); seed[123] = v_161.as_canonical_u64(); seed[124] = v_162.as_canonical_u64(); seed[125] = v_163.as_canonical_u64(); seed[126] = v_164.as_canonical_u64(); seed[127] = v_165.as_canonical_u64(); seed[128] = v_166.as_canonical_u64(); seed[129] = v_167.as_canonical_u64(); seed[130] = v_168.as_canonical_u64(); seed[131] = v_169.as_canonical_u64(); seed[132] = v_170.as_canonical_u64(); seed[133] = v_171.as_canonical_u64(); seed[134] = v_172.as_canonical_u64(); seed[135] = v_173.as_canonical_u64(); seed[136] = v_174.as_canonical_u64(); seed[137] = v_175.as_canonical_u64(); seed[138] = v_176.as_canonical_u64(); seed[139] = v_177.as_canonical_u64(); seed[140] = v_178.as_canonical_u64(); seed[141] = v_179.as_canonical_u64(); seed[142] = v_180.as_canonical_u64(); seed[143] = v_181.as_canonical_u64(); seed[144] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed[145] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed[146] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 17, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[147] = v_186.as_canonical_u64(); seed[148] = v_187.as_canonical_u64(); seed[149] = v_188.as_canonical_u64(); seed[150] = v_189.as_canonical_u64(); seed[151] = v_190.as_canonical_u64(); seed[152] = v_191.as_canonical_u64(); seed[153] = v_192.as_canonical_u64(); seed[154] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed[155] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, 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])?; seed[156] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed[157] = v_196.as_canonical_u64(); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 795, &[v_0])?; seed[71] = v_197.as_canonical_u64(); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 795, &[v_0])?; seed[72] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed[73] = v_200.as_canonical_u64(); seed[74] = v_201.as_canonical_u64(); seed[75] = v_202.as_canonical_u64(); seed[76] = v_203.as_canonical_u64(); seed[77] = v_204.as_canonical_u64(); seed[78] = v_205.as_canonical_u64(); seed[79] = v_206.as_canonical_u64(); seed[80] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = context.call::<1>(56, 7, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed[81] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed[82] = v_217.as_canonical_u64(); seed[83] = v_218.as_canonical_u64(); seed[84] = v_219.as_canonical_u64(); seed[85] = v_220.as_canonical_u64(); seed[86] = v_221.as_canonical_u64(); seed[87] = v_222.as_canonical_u64(); seed[88] = v_223.as_canonical_u64(); seed[89] = v_224.as_canonical_u64(); seed[90] = v_225.as_canonical_u64(); seed[91] = v_226.as_canonical_u64(); seed[92] = v_227.as_canonical_u64(); seed[93] = v_228.as_canonical_u64(); seed[94] = v_229.as_canonical_u64(); seed[95] = v_230.as_canonical_u64(); seed[96] = v_231.as_canonical_u64(); seed[97] = v_232.as_canonical_u64(); seed[98] = v_233.as_canonical_u64(); seed[99] = v_234.as_canonical_u64(); seed[100] = v_235.as_canonical_u64(); seed[101] = v_236.as_canonical_u64(); seed[102] = v_237.as_canonical_u64(); seed[103] = v_238.as_canonical_u64(); seed[104] = v_239.as_canonical_u64(); seed[105] = v_240.as_canonical_u64(); seed[106] = v_241.as_canonical_u64(); seed[107] = v_242.as_canonical_u64(); seed[108] = v_243.as_canonical_u64(); seed[109] = v_244.as_canonical_u64(); seed[110] = v_245.as_canonical_u64(); seed[111] = v_246.as_canonical_u64(); seed[112] = v_247.as_canonical_u64(); seed[113] = v_248.as_canonical_u64(); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 35, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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])?; seed[114] = v_266.as_canonical_u64(); seed[115] = v_267.as_canonical_u64(); seed[116] = v_268.as_canonical_u64(); seed[117] = v_269.as_canonical_u64(); seed[118] = v_270.as_canonical_u64(); seed[119] = v_271.as_canonical_u64(); seed[120] = v_272.as_canonical_u64(); seed[121] = v_273.as_canonical_u64(); seed[122] = v_274.as_canonical_u64(); seed[123] = v_275.as_canonical_u64(); seed[124] = v_276.as_canonical_u64(); seed[125] = v_277.as_canonical_u64(); seed[126] = v_278.as_canonical_u64(); seed[127] = v_279.as_canonical_u64(); seed[128] = v_280.as_canonical_u64(); seed[129] = v_281.as_canonical_u64(); seed[130] = v_282.as_canonical_u64(); seed[131] = v_283.as_canonical_u64(); seed[132] = v_284.as_canonical_u64(); seed[133] = v_285.as_canonical_u64(); seed[134] = v_286.as_canonical_u64(); seed[135] = v_287.as_canonical_u64(); seed[136] = v_288.as_canonical_u64(); seed[137] = v_289.as_canonical_u64(); seed[138] = v_290.as_canonical_u64(); seed[139] = v_291.as_canonical_u64(); seed[140] = v_292.as_canonical_u64(); seed[141] = v_293.as_canonical_u64(); seed[142] = v_294.as_canonical_u64(); seed[143] = v_295.as_canonical_u64(); seed[144] = v_296.as_canonical_u64(); seed[145] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed[146] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed[147] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed[148] = v_302.as_canonical_u64(); Ok(()) }, } } + +fn pack_31_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = context.call::<64>(3, 28, &[v_1])?; seed.u8(128, v_9); seed.u8(129, v_10); seed.u8(130, v_11); seed.u8(131, v_12); seed.u8(132, v_13); seed.u8(133, v_14); seed.u8(134, v_15); seed.u8(135, v_16); seed.u8(136, v_17); seed.u8(137, v_18); seed.u8(138, v_19); seed.u8(139, v_20); seed.u8(140, v_21); seed.u8(141, v_22); seed.u8(142, v_23); seed.u8(143, v_24); seed.u8(144, v_25); seed.u8(145, v_26); seed.u8(146, v_27); seed.u8(147, v_28); seed.u8(148, v_29); seed.u8(149, v_30); seed.u8(150, v_31); seed.u8(151, v_32); seed.u8(152, v_33); seed.u8(153, v_34); seed.u8(154, v_35); seed.u8(155, v_36); seed.u8(156, v_37); seed.u8(157, v_38); seed.u8(158, v_39); seed.u8(159, v_40); seed.u8(160, v_41); seed.u8(161, v_42); seed.u8(162, v_43); seed.u8(163, v_44); seed.u8(164, v_45); seed.u8(165, v_46); seed.u8(166, v_47); seed.u8(167, v_48); seed.u8(168, v_49); seed.u8(169, v_50); seed.u8(170, v_51); seed.u8(171, v_52); seed.u8(172, v_53); seed.u8(173, v_54); seed.u8(174, v_55); seed.u8(175, v_56); seed.u8(176, v_57); seed.u8(177, v_58); seed.u8(178, v_59); seed.u8(179, v_60); seed.u8(180, v_61); seed.u8(181, v_62); seed.u8(182, v_63); seed.u8(183, v_64); seed.u8(184, v_65); seed.u8(185, v_66); seed.u8(186, v_67); seed.u8(187, v_68); seed.u8(188, v_69); seed.u8(189, v_70); seed.u8(190, v_71); seed.u8(191, v_72); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 795, &[v_0])?; seed.u8(192, v_73); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed.u8(193, v_74); seed.u8(194, v_75); seed.u8(195, v_76); seed.u8(196, v_77); seed.u8(197, v_78); seed.u8(198, v_79); seed.u8(199, v_80); seed.u8(200, v_81); let [v_82]: [G; 1] = context.call::<1>(6, 7, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.u8(201, v_82); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed.u8(202, v_117); seed.u8(203, v_118); seed.u8(204, v_119); seed.u8(205, v_120); seed.u8(206, v_121); seed.u8(207, v_122); seed.u8(208, v_123); seed.u8(209, v_124); seed.u8(210, v_125); seed.u8(211, v_126); seed.u8(212, v_127); seed.u8(213, v_128); seed.u8(214, v_129); seed.u8(215, v_130); seed.u8(216, v_131); seed.u8(217, v_132); seed.u8(218, v_133); seed.u8(219, v_134); seed.u8(220, v_135); seed.u8(221, v_136); seed.u8(222, v_137); seed.u8(223, v_138); seed.u8(224, v_139); seed.u8(225, v_140); seed.u8(226, v_141); seed.u8(227, v_142); seed.u8(228, v_143); seed.u8(229, v_144); seed.u8(230, v_145); seed.u8(231, v_146); seed.u8(232, v_147); seed.u8(233, v_148); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 35, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed.u8(234, v_151); seed.u8(235, v_152); seed.u8(236, v_153); seed.u8(237, v_154); seed.u8(238, v_155); seed.u8(239, v_156); seed.u8(240, v_157); seed.u8(241, v_158); seed.u8(242, v_159); seed.u8(243, v_160); seed.u8(244, v_161); seed.u8(245, v_162); seed.u8(246, v_163); seed.u8(247, v_164); seed.u8(248, v_165); seed.u8(249, v_166); seed.u8(250, v_167); seed.u8(251, v_168); seed.u8(252, v_169); seed.u8(253, v_170); seed.u8(254, v_171); seed.u8(255, v_172); seed.u8(256, v_173); seed.u8(257, v_174); seed.u8(258, v_175); seed.u8(259, v_176); seed.u8(260, v_177); seed.u8(261, v_178); seed.u8(262, v_179); seed.u8(263, v_180); seed.u8(264, v_181); seed.u8(265, v_182); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed.u32(112, v_183); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed.u32(116, v_185); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 17, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.full(24, v_186); seed.full(32, v_187); seed.full(40, v_188); seed.full(48, v_189); seed.full(56, v_190); seed.full(64, v_191); seed.full(72, v_192); seed.full(80, v_193); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed.u32(120, v_194); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, 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])?; seed.u32(124, v_195); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed.full(88, v_196); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 795, &[v_0])?; seed.u8(192, v_197); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 795, &[v_0])?; seed.u8(193, v_199); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed.u8(194, v_200); seed.u8(195, v_201); seed.u8(196, v_202); seed.u8(197, v_203); seed.u8(198, v_204); seed.u8(199, v_205); seed.u8(200, v_206); seed.u8(201, v_207); let [v_208]: [G; 1] = context.call::<1>(56, 7, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed.u8(202, v_208); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed.u8(203, v_217); seed.u8(204, v_218); seed.u8(205, v_219); seed.u8(206, v_220); seed.u8(207, v_221); seed.u8(208, v_222); seed.u8(209, v_223); seed.u8(210, v_224); seed.u8(211, v_225); seed.u8(212, v_226); seed.u8(213, v_227); seed.u8(214, v_228); seed.u8(215, v_229); seed.u8(216, v_230); seed.u8(217, v_231); seed.u8(218, v_232); seed.u8(219, v_233); seed.u8(220, v_234); seed.u8(221, v_235); seed.u8(222, v_236); seed.u8(223, v_237); seed.u8(224, v_238); seed.u8(225, v_239); seed.u8(226, v_240); seed.u8(227, v_241); seed.u8(228, v_242); seed.u8(229, v_243); seed.u8(230, v_244); seed.u8(231, v_245); seed.u8(232, v_246); seed.u8(233, v_247); seed.u8(234, v_248); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 35, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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])?; seed.u8(235, v_266); seed.u8(236, v_267); seed.u8(237, v_268); seed.u8(238, v_269); seed.u8(239, v_270); seed.u8(240, v_271); seed.u8(241, v_272); seed.u8(242, v_273); seed.u8(243, v_274); seed.u8(244, v_275); seed.u8(245, v_276); seed.u8(246, v_277); seed.u8(247, v_278); seed.u8(248, v_279); seed.u8(249, v_280); seed.u8(250, v_281); seed.u8(251, v_282); seed.u8(252, v_283); seed.u8(253, v_284); seed.u8(254, v_285); seed.u8(255, v_286); seed.u8(256, v_287); seed.u8(257, v_288); seed.u8(258, v_289); seed.u8(259, v_290); seed.u8(260, v_291); seed.u8(261, v_292); seed.u8(262, v_293); seed.u8(263, v_294); seed.u8(264, v_295); seed.u8(265, v_296); seed.u32(112, v_297); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed.u32(116, v_299); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed.full(24, v_301); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed.full(32, v_302); Ok(()) }, } } + +fn pack_31_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = context.call::<64>(3, 28, &[v_1])?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); seed[47] = v_49.as_canonical_u64(); seed[48] = v_50.as_canonical_u64(); seed[49] = v_51.as_canonical_u64(); seed[50] = v_52.as_canonical_u64(); seed[51] = v_53.as_canonical_u64(); seed[52] = v_54.as_canonical_u64(); seed[53] = v_55.as_canonical_u64(); seed[54] = v_56.as_canonical_u64(); seed[55] = v_57.as_canonical_u64(); seed[56] = v_58.as_canonical_u64(); seed[57] = v_59.as_canonical_u64(); seed[58] = v_60.as_canonical_u64(); seed[59] = v_61.as_canonical_u64(); seed[60] = v_62.as_canonical_u64(); seed[61] = v_63.as_canonical_u64(); seed[62] = v_64.as_canonical_u64(); seed[63] = v_65.as_canonical_u64(); seed[64] = v_66.as_canonical_u64(); seed[65] = v_67.as_canonical_u64(); seed[66] = v_68.as_canonical_u64(); seed[67] = v_69.as_canonical_u64(); seed[68] = v_70.as_canonical_u64(); seed[69] = v_71.as_canonical_u64(); seed[70] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 795, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed[72] = v_74.as_canonical_u64(); seed[73] = v_75.as_canonical_u64(); seed[74] = v_76.as_canonical_u64(); seed[75] = v_77.as_canonical_u64(); seed[76] = v_78.as_canonical_u64(); seed[77] = v_79.as_canonical_u64(); seed[78] = v_80.as_canonical_u64(); seed[79] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(6, 7, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[80] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_117.as_canonical_u64(); seed[82] = v_118.as_canonical_u64(); seed[83] = v_119.as_canonical_u64(); seed[84] = v_120.as_canonical_u64(); seed[85] = v_121.as_canonical_u64(); seed[86] = v_122.as_canonical_u64(); seed[87] = v_123.as_canonical_u64(); seed[88] = v_124.as_canonical_u64(); seed[89] = v_125.as_canonical_u64(); seed[90] = v_126.as_canonical_u64(); seed[91] = v_127.as_canonical_u64(); seed[92] = v_128.as_canonical_u64(); seed[93] = v_129.as_canonical_u64(); seed[94] = v_130.as_canonical_u64(); seed[95] = v_131.as_canonical_u64(); seed[96] = v_132.as_canonical_u64(); seed[97] = v_133.as_canonical_u64(); seed[98] = v_134.as_canonical_u64(); seed[99] = v_135.as_canonical_u64(); seed[100] = v_136.as_canonical_u64(); seed[101] = v_137.as_canonical_u64(); seed[102] = v_138.as_canonical_u64(); seed[103] = v_139.as_canonical_u64(); seed[104] = v_140.as_canonical_u64(); seed[105] = v_141.as_canonical_u64(); seed[106] = v_142.as_canonical_u64(); seed[107] = v_143.as_canonical_u64(); seed[108] = v_144.as_canonical_u64(); seed[109] = v_145.as_canonical_u64(); seed[110] = v_146.as_canonical_u64(); seed[111] = v_147.as_canonical_u64(); seed[112] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 35, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed[113] = v_151.as_canonical_u64(); seed[114] = v_152.as_canonical_u64(); seed[115] = v_153.as_canonical_u64(); seed[116] = v_154.as_canonical_u64(); seed[117] = v_155.as_canonical_u64(); seed[118] = v_156.as_canonical_u64(); seed[119] = v_157.as_canonical_u64(); seed[120] = v_158.as_canonical_u64(); seed[121] = v_159.as_canonical_u64(); seed[122] = v_160.as_canonical_u64(); seed[123] = v_161.as_canonical_u64(); seed[124] = v_162.as_canonical_u64(); seed[125] = v_163.as_canonical_u64(); seed[126] = v_164.as_canonical_u64(); seed[127] = v_165.as_canonical_u64(); seed[128] = v_166.as_canonical_u64(); seed[129] = v_167.as_canonical_u64(); seed[130] = v_168.as_canonical_u64(); seed[131] = v_169.as_canonical_u64(); seed[132] = v_170.as_canonical_u64(); seed[133] = v_171.as_canonical_u64(); seed[134] = v_172.as_canonical_u64(); seed[135] = v_173.as_canonical_u64(); seed[136] = v_174.as_canonical_u64(); seed[137] = v_175.as_canonical_u64(); seed[138] = v_176.as_canonical_u64(); seed[139] = v_177.as_canonical_u64(); seed[140] = v_178.as_canonical_u64(); seed[141] = v_179.as_canonical_u64(); seed[142] = v_180.as_canonical_u64(); seed[143] = v_181.as_canonical_u64(); seed[144] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed[145] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed[146] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 17, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[147] = v_186.as_canonical_u64(); seed[148] = v_187.as_canonical_u64(); seed[149] = v_188.as_canonical_u64(); seed[150] = v_189.as_canonical_u64(); seed[151] = v_190.as_canonical_u64(); seed[152] = v_191.as_canonical_u64(); seed[153] = v_192.as_canonical_u64(); seed[154] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed[155] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, 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])?; seed[156] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = context.check_returned::<1>(51, 27, &[v_0, v_185, v_150, v_150, v_194, v_195, v_183])?; seed[157] = v_196.as_canonical_u64(); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 795, &[v_0])?; seed[71] = v_197.as_canonical_u64(); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 795, &[v_0])?; seed[72] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed[73] = v_200.as_canonical_u64(); seed[74] = v_201.as_canonical_u64(); seed[75] = v_202.as_canonical_u64(); seed[76] = v_203.as_canonical_u64(); seed[77] = v_204.as_canonical_u64(); seed[78] = v_205.as_canonical_u64(); seed[79] = v_206.as_canonical_u64(); seed[80] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = context.call::<1>(56, 7, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed[81] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed[82] = v_217.as_canonical_u64(); seed[83] = v_218.as_canonical_u64(); seed[84] = v_219.as_canonical_u64(); seed[85] = v_220.as_canonical_u64(); seed[86] = v_221.as_canonical_u64(); seed[87] = v_222.as_canonical_u64(); seed[88] = v_223.as_canonical_u64(); seed[89] = v_224.as_canonical_u64(); seed[90] = v_225.as_canonical_u64(); seed[91] = v_226.as_canonical_u64(); seed[92] = v_227.as_canonical_u64(); seed[93] = v_228.as_canonical_u64(); seed[94] = v_229.as_canonical_u64(); seed[95] = v_230.as_canonical_u64(); seed[96] = v_231.as_canonical_u64(); seed[97] = v_232.as_canonical_u64(); seed[98] = v_233.as_canonical_u64(); seed[99] = v_234.as_canonical_u64(); seed[100] = v_235.as_canonical_u64(); seed[101] = v_236.as_canonical_u64(); seed[102] = v_237.as_canonical_u64(); seed[103] = v_238.as_canonical_u64(); seed[104] = v_239.as_canonical_u64(); seed[105] = v_240.as_canonical_u64(); seed[106] = v_241.as_canonical_u64(); seed[107] = v_242.as_canonical_u64(); seed[108] = v_243.as_canonical_u64(); seed[109] = v_244.as_canonical_u64(); seed[110] = v_245.as_canonical_u64(); seed[111] = v_246.as_canonical_u64(); seed[112] = v_247.as_canonical_u64(); seed[113] = v_248.as_canonical_u64(); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 35, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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])?; seed[114] = v_266.as_canonical_u64(); seed[115] = v_267.as_canonical_u64(); seed[116] = v_268.as_canonical_u64(); seed[117] = v_269.as_canonical_u64(); seed[118] = v_270.as_canonical_u64(); seed[119] = v_271.as_canonical_u64(); seed[120] = v_272.as_canonical_u64(); seed[121] = v_273.as_canonical_u64(); seed[122] = v_274.as_canonical_u64(); seed[123] = v_275.as_canonical_u64(); seed[124] = v_276.as_canonical_u64(); seed[125] = v_277.as_canonical_u64(); seed[126] = v_278.as_canonical_u64(); seed[127] = v_279.as_canonical_u64(); seed[128] = v_280.as_canonical_u64(); seed[129] = v_281.as_canonical_u64(); seed[130] = v_282.as_canonical_u64(); seed[131] = v_283.as_canonical_u64(); seed[132] = v_284.as_canonical_u64(); seed[133] = v_285.as_canonical_u64(); seed[134] = v_286.as_canonical_u64(); seed[135] = v_287.as_canonical_u64(); seed[136] = v_288.as_canonical_u64(); seed[137] = v_289.as_canonical_u64(); seed[138] = v_290.as_canonical_u64(); seed[139] = v_291.as_canonical_u64(); seed[140] = v_292.as_canonical_u64(); seed[141] = v_293.as_canonical_u64(); seed[142] = v_294.as_canonical_u64(); seed[143] = v_295.as_canonical_u64(); seed[144] = v_296.as_canonical_u64(); seed[145] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed[146] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [v_2 + v_298]; let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed[147] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = context.check_returned::<1>(88, 27, &[v_0, v_299, v_265, v_300, v_3, v_301, v_5])?; seed[148] = v_302.as_canonical_u64(); Ok(()) }, } } + +fn write_31(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 65] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = [G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 66] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = [G::from_u64(seed[80])]; row[offsets.auxiliaries + 74] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; row[offsets.auxiliaries + 75] = v_83.as_canonical_u64(); let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = [G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 76] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_148.as_canonical_u64(); let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144])]; row[offsets.auxiliaries + 108] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = [G::from_u64(seed[145])]; row[offsets.auxiliaries + 140] = v_183.as_canonical_u64(); let [v_185]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 141] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = [G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 142] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = [G::from_u64(seed[155])]; row[offsets.auxiliaries + 150] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = [G::from_u64(seed[156])]; row[offsets.auxiliaries + 151] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = [G::from_u64(seed[157])]; row[offsets.auxiliaries + 152] = v_196.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 65] = (v_2 - G::from_u64(1023)).inverse().as_canonical_u64(); let [v_197]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 66] = v_197.as_canonical_u64(); let [v_199]: [G; 1] = [G::from_u64(seed[72])]; row[offsets.auxiliaries + 67] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 68] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = [G::from_u64(seed[81])]; row[offsets.auxiliaries + 76] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; row[offsets.auxiliaries + 77] = v_210.as_canonical_u64(); let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; row[offsets.auxiliaries + 78] = g_inverse_value(v_212).as_canonical_u64(); row[offsets.auxiliaries + 79] = v_213.as_canonical_u64(); let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = [G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113])]; row[offsets.auxiliaries + 80] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_223.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_237.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_248.as_canonical_u64(); let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = [G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 112] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_273.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_274.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_275.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_277.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_279.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_281.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_283.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_284.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_285.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_286.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_287.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_297.as_canonical_u64(); let [v_299]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 144] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = [G::from_u64(seed[147])]; row[offsets.auxiliaries + 145] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = [G::from_u64(seed[148])]; row[offsets.auxiliaries + 146] = v_302.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_31: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 96, 100, 8, 104, 108, 16, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 112, 116, 24, 32, 40, 48, 56, 64, 72, 80, 120, 124, 88], bytes: 272 }; + +fn pack_35(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_35_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn pack_35_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; let [v_470]: [G; 1] = [v_462 + v_465]; let [v_471]: [G; 1] = [v_464 + v_467]; let [v_472]: [G; 1] = [v_466 + v_469]; let [v_473]: [G; 1] = [v_468 + v_463]; let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; let [v_532]: [G; 1] = [v_524 + v_527]; let [v_533]: [G; 1] = [v_526 + v_529]; let [v_534]: [G; 1] = [v_528 + v_531]; let [v_535]: [G; 1] = [v_530 + v_525]; let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; let [v_594]: [G; 1] = [v_586 + v_589]; let [v_595]: [G; 1] = [v_588 + v_591]; let [v_596]: [G; 1] = [v_590 + v_593]; let [v_597]: [G; 1] = [v_592 + v_587]; let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; let [v_656]: [G; 1] = [v_648 + v_651]; let [v_657]: [G; 1] = [v_650 + v_653]; let [v_658]: [G; 1] = [v_652 + v_655]; let [v_659]: [G; 1] = [v_654 + v_649]; let [v_660]: [G; 1] = [v_0 + v_166]; let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.check_returned::<32>(436, 35, &[v_660, v_443, v_444, v_445, v_446, v_505, v_506, v_507, v_508, v_567, v_568, v_569, v_570, v_629, v_630, v_631, v_632, v_656, v_657, v_658, v_659, v_470, v_471, v_472, v_473, v_532, v_533, v_534, v_535, v_594, v_595, v_596, v_597, v_580, v_581, v_582, v_583, v_642, v_643, v_644, v_645, v_456, v_457, v_458, v_459, v_518, v_519, v_520, v_521, v_515, v_516, v_517, v_514, v_577, v_578, v_579, v_576, v_639, v_640, v_641, v_638, v_453, v_454, v_455, v_452, 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])?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn write_35(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_35: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_43(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_0.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, 1u64 => { break 'yield_0 []; }, 2u64 => { break 'yield_0 []; }, 3u64 => { break 'yield_0 []; }, _ => { return Err(no_match(43, v_0)); }, } }; let [v_9]: [G; 1] = context.call::<1>(5, 42, &[v_1, v_2])?; seed[4] = v_9.as_canonical_u64(); Ok(()) }, } } + +fn pack_43_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_0.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, 1u64 => { break 'yield_0 []; }, 2u64 => { break 'yield_0 []; }, 3u64 => { break 'yield_0 []; }, _ => { return Err(no_match(43, v_0)); }, } }; let [v_9]: [G; 1] = context.call::<1>(5, 42, &[v_1, v_2])?; seed.u8(11, v_9); Ok(()) }, } } + +fn pack_43_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_0.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, 1u64 => { break 'yield_0 []; }, 2u64 => { break 'yield_0 []; }, 3u64 => { break 'yield_0 []; }, _ => { return Err(no_match(43, v_0)); }, } }; let [v_9]: [G; 1] = context.call::<1>(5, 42, &[v_1, v_2])?; seed[4] = v_9.as_canonical_u64(); Ok(()) }, } } + +fn write_43(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); match v_0.as_canonical_u64() { _ => { let [v_7]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, 1u64 => { let [v_4]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_4]; }, 2u64 => { let [v_5]: [G; 1] = [G::from_u64(2)]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_5]; }, 3u64 => { let [v_6]: [G; 1] = [G::from_u64(3)]; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_6]; }, _ => { return Err(no_match(43, v_0)); }, } }; row[offsets.auxiliaries + 1] = v_7.as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_9.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, } } + +static SCHEMA_43: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11], bytes: 16 }; + +fn pack_79(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); Ok(()) } + +fn pack_79_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(28, v_1); seed.full(8, v_2); seed.full(16, v_3); Ok(()) } + +fn pack_79_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); Ok(()) } + +fn write_79(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(79, v_1)) }, } } + +static SCHEMA_79: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 24, 28, 8, 16], bytes: 32 }; + +fn pack_80(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_0)?; seed[3] = v_3.as_canonical_u64(); seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [v_1 - v_6]; let [v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 9] = context.call::<9>(4, 80, &[v_5, v_7])?; seed[6] = v_8.as_canonical_u64(); seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(80, v_3)) }, } }, } } + +fn pack_80_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_0)?; seed.u8(104, v_3); seed.full(16, v_4); seed.u32(100, v_5); match v_3.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [v_1 - v_6]; let [v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 9] = context.call::<9>(4, 80, &[v_5, v_7])?; seed.full(24, v_8); seed.full(32, v_9); seed.full(40, v_10); seed.full(48, v_11); seed.full(56, v_12); seed.full(64, v_13); seed.full(72, v_14); seed.full(80, v_15); seed.full(88, v_16); Ok(()) }, _ => { Err(no_match(80, v_3)) }, } }, } } + +fn pack_80_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_0)?; seed[3] = v_3.as_canonical_u64(); seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [v_1 - v_6]; let [v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 9] = context.call::<9>(4, 80, &[v_5, v_7])?; seed[6] = v_8.as_canonical_u64(); seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(80, v_3)) }, } }, } } + +fn write_80(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_3, v_4, v_5]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 9] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(80, v_3)) }, } }, } } + +static SCHEMA_80: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 96, 8, 104, 16, 100, 24, 32, 40, 48, 56, 64, 72, 80, 88], bytes: 112 }; + +fn pack_83(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 8] = [G::from_bool((v_2.as_canonical_u64() & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 7) & 1) != 0)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_14 * v_6]; let [v_23]: [G; 1] = [v_21 + v_22]; let [v_24]: [G; 1] = [v_4 + v_23]; match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = [v_24 + v_26]; let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 9] = context.call::<9>(18, 80, &[v_3, v_27])?; seed[5] = v_28.as_canonical_u64(); seed[6] = v_29.as_canonical_u64(); seed[7] = v_30.as_canonical_u64(); seed[8] = v_31.as_canonical_u64(); seed[9] = v_32.as_canonical_u64(); seed[10] = v_33.as_canonical_u64(); seed[11] = v_34.as_canonical_u64(); seed[12] = v_35.as_canonical_u64(); seed[13] = v_36.as_canonical_u64(); let [v_37]: [G; 1] = context.call::<1>(19, 6, &[v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed[14] = v_37.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_27.as_canonical_u64() { 1u64 => { break 'yield_0 []; }, _ => { break 'yield_0 []; }, } }; Ok(()) }, } }, _ => { Err(no_match(83, v_1)) }, } } + +fn pack_83_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(80, v_1); seed.u8(81, v_2); seed.u32(76, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 8] = [G::from_bool((v_2.as_canonical_u64() & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 7) & 1) != 0)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_14 * v_6]; let [v_23]: [G; 1] = [v_21 + v_22]; let [v_24]: [G; 1] = [v_4 + v_23]; match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = [v_24 + v_26]; let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 9] = context.call::<9>(18, 80, &[v_3, v_27])?; seed.u8(82, v_28); seed.full(8, v_29); seed.full(16, v_30); seed.full(24, v_31); seed.full(32, v_32); seed.full(40, v_33); seed.full(48, v_34); seed.full(56, v_35); seed.full(64, v_36); let [v_37]: [G; 1] = context.call::<1>(19, 6, &[v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed.u8(83, v_37); let []: [G; 0] = 'yield_0: { match v_27.as_canonical_u64() { 1u64 => { break 'yield_0 []; }, _ => { break 'yield_0 []; }, } }; Ok(()) }, } }, _ => { Err(no_match(83, v_1)) }, } } + +fn pack_83_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 8] = [G::from_bool((v_2.as_canonical_u64() & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 7) & 1) != 0)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_14 * v_6]; let [v_23]: [G; 1] = [v_21 + v_22]; let [v_24]: [G; 1] = [v_4 + v_23]; match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = [v_24 + v_26]; let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 9] = context.call::<9>(18, 80, &[v_3, v_27])?; seed[5] = v_28.as_canonical_u64(); seed[6] = v_29.as_canonical_u64(); seed[7] = v_30.as_canonical_u64(); seed[8] = v_31.as_canonical_u64(); seed[9] = v_32.as_canonical_u64(); seed[10] = v_33.as_canonical_u64(); seed[11] = v_34.as_canonical_u64(); seed[12] = v_35.as_canonical_u64(); seed[13] = v_36.as_canonical_u64(); let [v_37]: [G; 1] = context.call::<1>(19, 6, &[v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed[14] = v_37.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_27.as_canonical_u64() { 1u64 => { break 'yield_0 []; }, _ => { break 'yield_0 []; }, } }; Ok(()) }, } }, _ => { Err(no_match(83, v_1)) }, } } + +fn write_83(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 8] = [G::from_bool((v_2.as_canonical_u64() & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_14 * v_6]; let [v_23]: [G; 1] = [v_21 + v_22]; let [v_24]: [G; 1] = [v_4 + v_23]; match v_7.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 12] = (v_7 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = [v_24 + v_26]; let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 9] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 13] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_36.as_canonical_u64(); let [v_37]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 22] = v_37.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_27.as_canonical_u64() { 1u64 => { let [v_38]: [G; 1] = [G::from_u64(8)]; let [v_39]: [G; 1] = [Bytes2::less_than(&v_28, &v_38)]; row[offsets.auxiliaries + 23] = v_39.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, _ => { row[offsets.auxiliaries + 23] = (v_27 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(83, v_1)) }, } } + +static SCHEMA_83: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8], offsets: &[0, 72, 80, 81, 76, 82, 8, 16, 24, 32, 40, 48, 56, 64, 83], bytes: 88 }; + +fn pack_85(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10]: [G; 1] = context.call::<1>(0, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[11] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11, v_12]: [G; 2] = context.call::<2>(1, 92, &[v_1])?; seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(7)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(4, &[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])?; seed[14] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 8] = context.call::<8>(5, 18, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); let [v_24, v_25]: [G; 2] = context.returned::<2>(6)?; seed[23] = v_24.as_canonical_u64(); seed[24] = v_25.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_10)) }, } } + +fn pack_85_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10]: [G; 1] = context.call::<1>(0, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.u8(180, v_10); match v_10.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11, v_12]: [G; 2] = context.call::<2>(1, 92, &[v_1])?; seed.full(80, v_11); seed.u32(172, v_12); let [v_13]: [G; 1] = [G::from_u64(7)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(4, &[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])?; seed.u32(176, v_15); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 8] = context.call::<8>(5, 18, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(88, v_16); seed.full(96, v_17); seed.full(104, v_18); seed.full(112, v_19); seed.full(120, v_20); seed.full(128, v_21); seed.full(136, v_22); seed.full(144, v_23); let [v_24, v_25]: [G; 2] = context.returned::<2>(6)?; seed.full(152, v_24); seed.full(160, v_25); Ok(()) }, _ => { Err(no_match(85, v_10)) }, } } + +fn pack_85_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10]: [G; 1] = context.call::<1>(0, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[11] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11, v_12]: [G; 2] = context.call::<2>(1, 92, &[v_1])?; seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(7)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(4, &[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])?; seed[14] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 8] = context.call::<8>(5, 18, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); let [v_24, v_25]: [G; 2] = context.check_returned::<2>(6, 85, &[v_15, v_12, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23])?; seed[23] = v_24.as_canonical_u64(); seed[24] = v_25.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_10)) }, } } + +fn write_85(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let [v_10]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12]: [G; 2] = [G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 4] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 8] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_23.as_canonical_u64(); let [v_24, v_25]: [G; 2] = [G::from_u64(seed[23]), G::from_u64(seed[24])]; row[offsets.auxiliaries + 13] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_25.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_10)) }, } } + +static SCHEMA_85: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 168, 16, 24, 32, 40, 48, 56, 64, 72, 180, 80, 172, 176, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160], bytes: 184 }; + +fn pack_88(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 79, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_15, v_16, v_17]: [G; 3] = context.call::<3>(7, 87, &[v_3, v_4, v_5, v_6])?; seed[4] = v_15.as_canonical_u64(); seed[5] = v_16.as_canonical_u64(); seed[6] = v_17.as_canonical_u64(); Ok(()) } + +fn pack_88_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 79, &[v_0])?; seed.u8(20, v_1); seed.full(8, v_2); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_15, v_16, v_17]: [G; 3] = context.call::<3>(7, 87, &[v_3, v_4, v_5, v_6])?; seed.u8(21, v_15); seed.u8(22, v_16); seed.u8(23, v_17); Ok(()) } + +fn pack_88_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 79, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_15, v_16, v_17]: [G; 3] = context.call::<3>(7, 87, &[v_3, v_4, v_5, v_6])?; seed[4] = v_15.as_canonical_u64(); seed[5] = v_16.as_canonical_u64(); seed[6] = v_17.as_canonical_u64(); Ok(()) } + +fn write_88(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2]: [G; 2] = [G::from_u64(seed[2]), G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_15, v_16, v_17]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 11] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_88: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 16, 20, 8, 21, 22, 23], bytes: 24 }; + +fn pack_89(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 79, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_13, v_14, v_15]: [G; 3] = context.call::<3>(5, 87, &[v_3, v_4, v_5, v_6])?; seed[4] = v_13.as_canonical_u64(); seed[5] = v_14.as_canonical_u64(); seed[6] = v_15.as_canonical_u64(); let [v_16, v_17]: [G; 2] = context.call::<2>(6, 86, &[v_7, v_8])?; seed[7] = v_16.as_canonical_u64(); seed[8] = v_17.as_canonical_u64(); Ok(()) } + +fn pack_89_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 79, &[v_0])?; seed.u8(20, v_1); seed.full(8, v_2); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_13, v_14, v_15]: [G; 3] = context.call::<3>(5, 87, &[v_3, v_4, v_5, v_6])?; seed.u8(21, v_13); seed.u8(22, v_14); seed.u8(23, v_15); let [v_16, v_17]: [G; 2] = context.call::<2>(6, 86, &[v_7, v_8])?; seed.u8(24, v_16); seed.u8(25, v_17); Ok(()) } + +fn pack_89_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 79, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_13, v_14, v_15]: [G; 3] = context.call::<3>(5, 87, &[v_3, v_4, v_5, v_6])?; seed[4] = v_13.as_canonical_u64(); seed[5] = v_14.as_canonical_u64(); seed[6] = v_15.as_canonical_u64(); let [v_16, v_17]: [G; 2] = context.call::<2>(6, 86, &[v_7, v_8])?; seed[7] = v_16.as_canonical_u64(); seed[8] = v_17.as_canonical_u64(); Ok(()) } + +fn write_89(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2]: [G; 2] = [G::from_u64(seed[2]), G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_13, v_14, v_15]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); let [v_16, v_17]: [G; 2] = [G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_89: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 16, 20, 8, 21, 22, 23, 24, 25], bytes: 32 }; + +fn pack_92(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.call::<10>(0, 83, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed[12] = v_12.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_13]: [G; 1] = [G::from_u64(1)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(5, &[v_13, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14])?; seed[12] = v_15.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(6, 81, &[v_10])?; seed[12] = v_16.as_canonical_u64(); seed[13] = v_17.as_canonical_u64(); seed[14] = v_18.as_canonical_u64(); seed[15] = v_19.as_canonical_u64(); seed[16] = v_20.as_canonical_u64(); seed[17] = v_21.as_canonical_u64(); seed[18] = v_22.as_canonical_u64(); seed[19] = v_23.as_canonical_u64(); seed[20] = v_24.as_canonical_u64(); let [v_25, v_26]: [G; 2] = context.call::<2>(7, 84, &[v_24, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[21] = v_25.as_canonical_u64(); seed[22] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [G::from_u64(0)]; let [v_29]: [G; 1] = context.store(10, &[v_27, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_25, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed[23] = v_29.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38]: [G; 9] = context.call::<9>(11, 81, &[v_10])?; seed[12] = v_30.as_canonical_u64(); seed[13] = v_31.as_canonical_u64(); seed[14] = v_32.as_canonical_u64(); seed[15] = v_33.as_canonical_u64(); seed[16] = v_34.as_canonical_u64(); seed[17] = v_35.as_canonical_u64(); seed[18] = v_36.as_canonical_u64(); seed[19] = v_37.as_canonical_u64(); seed[20] = v_38.as_canonical_u64(); let [v_39, v_40]: [G; 2] = context.call::<2>(12, 84, &[v_38, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[21] = v_39.as_canonical_u64(); seed[22] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(3)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(15, &[v_41, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_39, v_42, v_42, v_42, v_42, v_42, v_42, v_42, v_42])?; seed[23] = v_43.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 9] = context.call::<9>(16, 81, &[v_10])?; seed[12] = v_44.as_canonical_u64(); seed[13] = v_45.as_canonical_u64(); seed[14] = v_46.as_canonical_u64(); seed[15] = v_47.as_canonical_u64(); seed[16] = v_48.as_canonical_u64(); seed[17] = v_49.as_canonical_u64(); seed[18] = v_50.as_canonical_u64(); seed[19] = v_51.as_canonical_u64(); seed[20] = v_52.as_canonical_u64(); let [v_53, v_54]: [G; 2] = context.call::<2>(17, 92, &[v_52])?; seed[21] = v_53.as_canonical_u64(); seed[22] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(4)]; let [v_56]: [G; 1] = context.store(19, &[v_55, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_53])?; seed[23] = v_56.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_57]: [G; 1] = [G::from_u64(5)]; let [v_58]: [G; 1] = [G::from_u64(0)]; let [v_59]: [G; 1] = context.store(22, &[v_57, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58])?; seed[12] = v_59.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_60]: [G; 1] = [G::from_u64(6)]; let [v_61]: [G; 1] = [G::from_u64(0)]; let [v_62]: [G; 1] = context.store(25, &[v_60, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61])?; seed[12] = v_62.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = context.call::<1>(26, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_63.as_canonical_u64(); let [v_65, v_66]: [G; 2] = context.call::<2>(29, 92, &[v_10])?; seed[13] = v_65.as_canonical_u64(); seed[14] = v_66.as_canonical_u64(); let [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]: [G; 18] = context.load::<18>(30, v_65)?; seed[15] = v_67.as_canonical_u64(); seed[16] = v_68.as_canonical_u64(); seed[17] = v_69.as_canonical_u64(); seed[18] = v_70.as_canonical_u64(); seed[19] = v_71.as_canonical_u64(); seed[20] = v_72.as_canonical_u64(); seed[21] = v_73.as_canonical_u64(); seed[22] = v_74.as_canonical_u64(); seed[23] = v_75.as_canonical_u64(); seed[24] = v_76.as_canonical_u64(); seed[25] = v_77.as_canonical_u64(); seed[26] = v_78.as_canonical_u64(); seed[27] = v_79.as_canonical_u64(); seed[28] = v_80.as_canonical_u64(); seed[29] = v_81.as_canonical_u64(); seed[30] = v_82.as_canonical_u64(); seed[31] = v_83.as_canonical_u64(); seed[32] = v_84.as_canonical_u64(); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = context.returned::<2>(34)?; seed[33] = v_87.as_canonical_u64(); seed[34] = v_88.as_canonical_u64(); Ok(()) }, _ => { let [v_89, v_90]: [G; 2] = context.returned::<2>(35)?; seed[33] = v_89.as_canonical_u64(); seed[34] = v_90.as_canonical_u64(); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = context.call::<1>(36, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_91.as_canonical_u64(); let [v_93, v_94]: [G; 2] = context.returned::<2>(39)?; seed[13] = v_93.as_canonical_u64(); seed[14] = v_94.as_canonical_u64(); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = context.call::<1>(40, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_95.as_canonical_u64(); let [v_97, v_98]: [G; 2] = context.returned::<2>(43)?; seed[13] = v_97.as_canonical_u64(); seed[14] = v_98.as_canonical_u64(); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = context.returned::<2>(44)?; seed[12] = v_99.as_canonical_u64(); seed[13] = v_100.as_canonical_u64(); Ok(()) }, 11u64 => { let [v_101]: [G; 1] = [G::from_u64(11)]; let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.store(47, &[v_101, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102])?; seed[12] = v_103.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(92, v_1)) }, } } + +fn pack_92_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.call::<10>(0, 83, &[v_0])?; seed.u8(256, v_1); seed.u8(257, v_2); seed.full(8, v_3); seed.full(16, v_4); seed.full(24, v_5); seed.full(32, v_6); seed.full(40, v_7); seed.full(48, v_8); seed.full(56, v_9); seed.u32(252, v_10); match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed.full(64, v_12); Ok(()) }, 1u64 => { let [v_13]: [G; 1] = [G::from_u64(1)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(5, &[v_13, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14])?; seed.full(64, v_15); Ok(()) }, 2u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(6, 81, &[v_10])?; seed.full(64, v_16); seed.full(72, v_17); seed.full(80, v_18); seed.full(88, v_19); seed.full(96, v_20); seed.full(104, v_21); seed.full(112, v_22); seed.full(120, v_23); seed.full(128, v_24); let [v_25, v_26]: [G; 2] = context.call::<2>(7, 84, &[v_24, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(136, v_25); seed.full(144, v_26); let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [G::from_u64(0)]; let [v_29]: [G; 1] = context.store(10, &[v_27, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_25, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed.full(152, v_29); Ok(()) }, 3u64 => { let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38]: [G; 9] = context.call::<9>(11, 81, &[v_10])?; seed.full(64, v_30); seed.full(72, v_31); seed.full(80, v_32); seed.full(88, v_33); seed.full(96, v_34); seed.full(104, v_35); seed.full(112, v_36); seed.full(120, v_37); seed.full(128, v_38); let [v_39, v_40]: [G; 2] = context.call::<2>(12, 84, &[v_38, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(136, v_39); seed.full(144, v_40); let [v_41]: [G; 1] = [G::from_u64(3)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(15, &[v_41, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_39, v_42, v_42, v_42, v_42, v_42, v_42, v_42, v_42])?; seed.full(152, v_43); Ok(()) }, 4u64 => { let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 9] = context.call::<9>(16, 81, &[v_10])?; seed.full(64, v_44); seed.full(72, v_45); seed.full(80, v_46); seed.full(88, v_47); seed.full(96, v_48); seed.full(104, v_49); seed.full(112, v_50); seed.full(120, v_51); seed.full(128, v_52); let [v_53, v_54]: [G; 2] = context.call::<2>(17, 92, &[v_52])?; seed.full(136, v_53); seed.full(144, v_54); let [v_55]: [G; 1] = [G::from_u64(4)]; let [v_56]: [G; 1] = context.store(19, &[v_55, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_53])?; seed.full(152, v_56); Ok(()) }, 5u64 => { let [v_57]: [G; 1] = [G::from_u64(5)]; let [v_58]: [G; 1] = [G::from_u64(0)]; let [v_59]: [G; 1] = context.store(22, &[v_57, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58])?; seed.full(64, v_59); Ok(()) }, 6u64 => { let [v_60]: [G; 1] = [G::from_u64(6)]; let [v_61]: [G; 1] = [G::from_u64(0)]; let [v_62]: [G; 1] = context.store(25, &[v_60, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61])?; seed.full(64, v_62); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = context.call::<1>(26, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(64, v_63); let [v_65, v_66]: [G; 2] = context.call::<2>(29, 92, &[v_10])?; seed.full(72, v_65); seed.full(80, v_66); let [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]: [G; 18] = context.load::<18>(30, v_65)?; seed.full(88, v_67); seed.full(96, v_68); seed.full(104, v_69); seed.full(112, v_70); seed.full(120, v_71); seed.full(128, v_72); seed.full(136, v_73); seed.full(144, v_74); seed.full(152, v_75); seed.full(160, v_76); seed.full(168, v_77); seed.full(176, v_78); seed.full(184, v_79); seed.full(192, v_80); seed.full(200, v_81); seed.full(208, v_82); seed.full(216, v_83); seed.full(224, v_84); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = context.returned::<2>(34)?; seed.full(232, v_87); seed.full(240, v_88); Ok(()) }, _ => { let [v_89, v_90]: [G; 2] = context.returned::<2>(35)?; seed.full(232, v_89); seed.full(240, v_90); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = context.call::<1>(36, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(64, v_91); let [v_93, v_94]: [G; 2] = context.returned::<2>(39)?; seed.full(72, v_93); seed.full(80, v_94); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = context.call::<1>(40, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(64, v_95); let [v_97, v_98]: [G; 2] = context.returned::<2>(43)?; seed.full(72, v_97); seed.full(80, v_98); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = context.returned::<2>(44)?; seed.full(64, v_99); seed.full(72, v_100); Ok(()) }, 11u64 => { let [v_101]: [G; 1] = [G::from_u64(11)]; let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.store(47, &[v_101, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102])?; seed.full(64, v_103); Ok(()) }, _ => { Err(no_match(92, v_1)) }, } } + +fn pack_92_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.call::<10>(0, 83, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed[12] = v_12.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_13]: [G; 1] = [G::from_u64(1)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(5, &[v_13, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14])?; seed[12] = v_15.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(6, 81, &[v_10])?; seed[12] = v_16.as_canonical_u64(); seed[13] = v_17.as_canonical_u64(); seed[14] = v_18.as_canonical_u64(); seed[15] = v_19.as_canonical_u64(); seed[16] = v_20.as_canonical_u64(); seed[17] = v_21.as_canonical_u64(); seed[18] = v_22.as_canonical_u64(); seed[19] = v_23.as_canonical_u64(); seed[20] = v_24.as_canonical_u64(); let [v_25, v_26]: [G; 2] = context.call::<2>(7, 84, &[v_24, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[21] = v_25.as_canonical_u64(); seed[22] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [G::from_u64(0)]; let [v_29]: [G; 1] = context.store(10, &[v_27, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_25, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed[23] = v_29.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38]: [G; 9] = context.call::<9>(11, 81, &[v_10])?; seed[12] = v_30.as_canonical_u64(); seed[13] = v_31.as_canonical_u64(); seed[14] = v_32.as_canonical_u64(); seed[15] = v_33.as_canonical_u64(); seed[16] = v_34.as_canonical_u64(); seed[17] = v_35.as_canonical_u64(); seed[18] = v_36.as_canonical_u64(); seed[19] = v_37.as_canonical_u64(); seed[20] = v_38.as_canonical_u64(); let [v_39, v_40]: [G; 2] = context.call::<2>(12, 84, &[v_38, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[21] = v_39.as_canonical_u64(); seed[22] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(3)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(15, &[v_41, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_39, v_42, v_42, v_42, v_42, v_42, v_42, v_42, v_42])?; seed[23] = v_43.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 9] = context.call::<9>(16, 81, &[v_10])?; seed[12] = v_44.as_canonical_u64(); seed[13] = v_45.as_canonical_u64(); seed[14] = v_46.as_canonical_u64(); seed[15] = v_47.as_canonical_u64(); seed[16] = v_48.as_canonical_u64(); seed[17] = v_49.as_canonical_u64(); seed[18] = v_50.as_canonical_u64(); seed[19] = v_51.as_canonical_u64(); seed[20] = v_52.as_canonical_u64(); let [v_53, v_54]: [G; 2] = context.call::<2>(17, 92, &[v_52])?; seed[21] = v_53.as_canonical_u64(); seed[22] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(4)]; let [v_56]: [G; 1] = context.store(19, &[v_55, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_53])?; seed[23] = v_56.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_57]: [G; 1] = [G::from_u64(5)]; let [v_58]: [G; 1] = [G::from_u64(0)]; let [v_59]: [G; 1] = context.store(22, &[v_57, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58])?; seed[12] = v_59.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_60]: [G; 1] = [G::from_u64(6)]; let [v_61]: [G; 1] = [G::from_u64(0)]; let [v_62]: [G; 1] = context.store(25, &[v_60, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61])?; seed[12] = v_62.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = context.call::<1>(26, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_63.as_canonical_u64(); let [v_65, v_66]: [G; 2] = context.call::<2>(29, 92, &[v_10])?; seed[13] = v_65.as_canonical_u64(); seed[14] = v_66.as_canonical_u64(); let [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]: [G; 18] = context.load::<18>(30, v_65)?; seed[15] = v_67.as_canonical_u64(); seed[16] = v_68.as_canonical_u64(); seed[17] = v_69.as_canonical_u64(); seed[18] = v_70.as_canonical_u64(); seed[19] = v_71.as_canonical_u64(); seed[20] = v_72.as_canonical_u64(); seed[21] = v_73.as_canonical_u64(); seed[22] = v_74.as_canonical_u64(); seed[23] = v_75.as_canonical_u64(); seed[24] = v_76.as_canonical_u64(); seed[25] = v_77.as_canonical_u64(); seed[26] = v_78.as_canonical_u64(); seed[27] = v_79.as_canonical_u64(); seed[28] = v_80.as_canonical_u64(); seed[29] = v_81.as_canonical_u64(); seed[30] = v_82.as_canonical_u64(); seed[31] = v_83.as_canonical_u64(); seed[32] = v_84.as_canonical_u64(); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = context.check_returned::<2>(34, 85, &[v_65, v_66, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[33] = v_87.as_canonical_u64(); seed[34] = v_88.as_canonical_u64(); Ok(()) }, _ => { let [v_89, v_90]: [G; 2] = context.check_returned::<2>(35, 85, &[v_65, v_66, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[33] = v_89.as_canonical_u64(); seed[34] = v_90.as_canonical_u64(); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = context.call::<1>(36, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_91.as_canonical_u64(); let [v_93, v_94]: [G; 2] = context.check_returned::<2>(39, 90, &[v_10, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[13] = v_93.as_canonical_u64(); seed[14] = v_94.as_canonical_u64(); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = context.call::<1>(40, 7, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_95.as_canonical_u64(); let [v_97, v_98]: [G; 2] = context.check_returned::<2>(43, 91, &[v_10, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[13] = v_97.as_canonical_u64(); seed[14] = v_98.as_canonical_u64(); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = context.check_returned::<2>(44, 93, &[v_10, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_99.as_canonical_u64(); seed[13] = v_100.as_canonical_u64(); Ok(()) }, 11u64 => { let [v_101]: [G; 1] = [G::from_u64(11)]; let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.store(47, &[v_101, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102])?; seed[12] = v_103.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(92, v_1)) }, } } + +fn write_92(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_15.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); let [v_25, v_26]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 20] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 22] = v_29.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 11] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_38.as_canonical_u64(); let [v_39, v_40]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 20] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_40.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 22] = v_43.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 11] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_52.as_canonical_u64(); let [v_53, v_54]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 20] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_54.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 22] = v_56.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_59]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_59.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_62]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_62.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_63.as_canonical_u64(); let [v_65, v_66]: [G; 2] = [G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_66.as_canonical_u64(); let [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]: [G; 18] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 14] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_84.as_canonical_u64(); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = [G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 32] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_88.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 32] = (v_67 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_89, v_90]: [G; 2] = [G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 33] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_90.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_91.as_canonical_u64(); let [v_93, v_94]: [G; 2] = [G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_94.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_95.as_canonical_u64(); let [v_97, v_98]: [G; 2] = [G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_98.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = [G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_100.as_canonical_u64(); row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); Ok(()) }, 11u64 => { let [v_103]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_103.as_canonical_u64(); row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(92, v_1)) }, } } + +static SCHEMA_92: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 248, 256, 257, 8, 16, 24, 32, 40, 48, 56, 252, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240], bytes: 264 }; + +fn pack_97(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let [v_9]: [G; 1] = context.call::<1>(0, 7, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[10] = v_9.as_canonical_u64(); match v_9.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = context.store(2, &[v_10, v_10, v_10])?; seed[11] = v_11.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13]: [G; 2] = context.call::<2>(3, 92, &[v_0])?; seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 8] = context.call::<8>(4, 18, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[13] = v_14.as_canonical_u64(); seed[14] = v_15.as_canonical_u64(); seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); let [v_22, v_23]: [G; 2] = context.call::<2>(5, 97, &[v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21])?; seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(7, &[v_24, v_12, v_22])?; seed[23] = v_25.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(97, v_9)) }, } } + +fn pack_97_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let [v_9]: [G; 1] = context.call::<1>(0, 7, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u8(168, v_9); match v_9.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = context.store(2, &[v_10, v_10, v_10])?; seed.full(72, v_11); Ok(()) }, 0u64 => { let [v_12, v_13]: [G; 2] = context.call::<2>(3, 92, &[v_0])?; seed.full(72, v_12); seed.u32(156, v_13); let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 8] = context.call::<8>(4, 18, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.full(80, v_14); seed.full(88, v_15); seed.full(96, v_16); seed.full(104, v_17); seed.full(112, v_18); seed.full(120, v_19); seed.full(128, v_20); seed.full(136, v_21); let [v_22, v_23]: [G; 2] = context.call::<2>(5, 97, &[v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21])?; seed.u32(160, v_22); seed.full(144, v_23); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(7, &[v_24, v_12, v_22])?; seed.u32(164, v_25); Ok(()) }, _ => { Err(no_match(97, v_9)) }, } } + +fn pack_97_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let [v_9]: [G; 1] = context.call::<1>(0, 7, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[10] = v_9.as_canonical_u64(); match v_9.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = context.store(2, &[v_10, v_10, v_10])?; seed[11] = v_11.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13]: [G; 2] = context.call::<2>(3, 92, &[v_0])?; seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 8] = context.call::<8>(4, 18, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[13] = v_14.as_canonical_u64(); seed[14] = v_15.as_canonical_u64(); seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); let [v_22, v_23]: [G; 2] = context.call::<2>(5, 97, &[v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21])?; seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(7, &[v_24, v_12, v_22])?; seed[23] = v_25.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(97, v_9)) }, } } + +fn write_97(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let [v_9]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); match v_9.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13]: [G; 2] = [G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 8] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_21.as_canonical_u64(); let [v_22, v_23]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_23.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 14] = v_25.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(97, v_9)) }, } } + +static SCHEMA_97: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 152, 8, 16, 24, 32, 40, 48, 56, 64, 168, 72, 156, 80, 88, 96, 104, 112, 120, 128, 136, 160, 144, 164], bytes: 176 }; + +fn pack_122(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 3u64 => { let [v_5, v_6]: [G; 2] = context.call::<2>(1, 122, &[v_2])?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = context.call::<1>(2, 780, &[v_6, v_3])?; seed[8] = v_7.as_canonical_u64(); Ok(()) }, _ => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = context.store(4, &[v_8, v_8, v_8])?; seed[6] = v_9.as_canonical_u64(); Ok(()) }, } } + +fn pack_122_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(48, v_1); seed.u32(36, v_2); seed.full(8, v_3); seed.full(16, v_4); match v_1.as_canonical_u64() { 3u64 => { let [v_5, v_6]: [G; 2] = context.call::<2>(1, 122, &[v_2])?; seed.full(24, v_5); seed.u32(40, v_6); let [v_7]: [G; 1] = context.call::<1>(2, 780, &[v_6, v_3])?; seed.u32(44, v_7); Ok(()) }, _ => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = context.store(4, &[v_8, v_8, v_8])?; seed.full(24, v_9); Ok(()) }, } } + +fn pack_122_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 3u64 => { let [v_5, v_6]: [G; 2] = context.call::<2>(1, 122, &[v_2])?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = context.call::<1>(2, 780, &[v_6, v_3])?; seed[8] = v_7.as_canonical_u64(); Ok(()) }, _ => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = context.store(4, &[v_8, v_8, v_8])?; seed[6] = v_9.as_canonical_u64(); Ok(()) }, } } + +fn write_122(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4]: [G; 4] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 3u64 => { let [v_5, v_6]: [G; 2] = [G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 5] = (v_1 - G::from_u64(3)).inverse().as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_122: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 32, 48, 36, 8, 16, 24, 40, 44], bytes: 56 }; + +fn pack_124(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 10] = context.load::<10>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(1)?; seed[14] = v_13.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 10] = context.load::<10>(2, v_1)?; seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); seed[17] = v_17.as_canonical_u64(); seed[18] = v_18.as_canonical_u64(); seed[19] = v_19.as_canonical_u64(); seed[20] = v_20.as_canonical_u64(); seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); seed[23] = v_23.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_24]: [G; 1] = context.returned::<1>(3)?; seed[24] = v_24.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 9] = context.call::<9>(4, 16, &[v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22])?; seed[24] = v_25.as_canonical_u64(); seed[25] = v_26.as_canonical_u64(); seed[26] = v_27.as_canonical_u64(); seed[27] = v_28.as_canonical_u64(); seed[28] = v_29.as_canonical_u64(); seed[29] = v_30.as_canonical_u64(); seed[30] = v_31.as_canonical_u64(); seed[31] = v_32.as_canonical_u64(); seed[32] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 9] = context.call::<9>(6, 16, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_2, v_34, v_34, v_34, v_34, v_34, v_34, v_34])?; seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [v_33 + v_43]; let [v_45]: [G; 1] = context.call::<1>(8, 124, &[v_12, v_23, v_44])?; seed[42] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = context.store(9, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_45])?; seed[43] = v_46.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(124, v_14)) }, } }, _ => { Err(no_match(124, v_3)) }, } } + +fn pack_124_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(45, v_3); seed.u8(46, v_4); seed.u8(47, v_5); seed.u8(48, v_6); seed.u8(49, v_7); seed.u8(50, v_8); seed.u8(51, v_9); seed.u8(52, v_10); seed.u8(53, v_11); seed.u32(24, v_12); match v_3.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(1)?; seed.u32(28, v_13); Ok(()) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 10] = context.load::<10>(2, v_1)?; seed.u32(28, v_14); seed.u8(54, v_15); seed.u8(55, v_16); seed.u8(56, v_17); seed.u8(57, v_18); seed.u8(58, v_19); seed.u8(59, v_20); seed.u8(60, v_21); seed.u8(61, v_22); seed.u32(32, v_23); match v_14.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_24]: [G; 1] = context.returned::<1>(3)?; seed.u32(36, v_24); Ok(()) }, } }, 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 9] = context.call::<9>(4, 16, &[v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22])?; seed.u32(36, v_25); seed.u8(62, v_26); seed.u8(63, v_27); seed.u8(64, v_28); seed.u8(65, v_29); seed.u8(66, v_30); seed.u8(67, v_31); seed.u8(68, v_32); seed.u8(69, v_33); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 9] = context.call::<9>(6, 16, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_2, v_34, v_34, v_34, v_34, v_34, v_34, v_34])?; seed.u8(70, v_35); seed.u8(71, v_36); seed.u8(72, v_37); seed.u8(73, v_38); seed.u8(74, v_39); seed.u8(75, v_40); seed.u8(76, v_41); seed.u8(77, v_42); seed.u8(78, v_43); let [v_44]: [G; 1] = [v_33 + v_43]; let [v_45]: [G; 1] = context.call::<1>(8, 124, &[v_12, v_23, v_44])?; seed.full(8, v_45); let [v_46]: [G; 1] = context.store(9, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_45])?; seed.u32(40, v_46); Ok(()) }, _ => { Err(no_match(124, v_14)) }, } }, _ => { Err(no_match(124, v_3)) }, } } + +fn pack_124_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 10] = context.load::<10>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.check_returned::<1>(1, 123, &[v_1])?; seed[14] = v_13.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 10] = context.load::<10>(2, v_1)?; seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); seed[17] = v_17.as_canonical_u64(); seed[18] = v_18.as_canonical_u64(); seed[19] = v_19.as_canonical_u64(); seed[20] = v_20.as_canonical_u64(); seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); seed[23] = v_23.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_24]: [G; 1] = context.check_returned::<1>(3, 123, &[v_0])?; seed[24] = v_24.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 9] = context.call::<9>(4, 16, &[v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22])?; seed[24] = v_25.as_canonical_u64(); seed[25] = v_26.as_canonical_u64(); seed[26] = v_27.as_canonical_u64(); seed[27] = v_28.as_canonical_u64(); seed[28] = v_29.as_canonical_u64(); seed[29] = v_30.as_canonical_u64(); seed[30] = v_31.as_canonical_u64(); seed[31] = v_32.as_canonical_u64(); seed[32] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 9] = context.call::<9>(6, 16, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_2, v_34, v_34, v_34, v_34, v_34, v_34, v_34])?; seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [v_33 + v_43]; let [v_45]: [G; 1] = context.call::<1>(8, 124, &[v_12, v_23, v_44])?; seed[42] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = context.store(9, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_45])?; seed[43] = v_46.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(124, v_14)) }, } }, _ => { Err(no_match(124, v_3)) }, } } + +fn write_124(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 10] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 11] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 10] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23])]; row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_23.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 21] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 9] = [G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 21] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_33.as_canonical_u64(); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 9] = [G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41])]; row[offsets.auxiliaries + 30] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_43.as_canonical_u64(); let [v_45]: [G; 1] = [G::from_u64(seed[42])]; row[offsets.auxiliaries + 39] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = [G::from_u64(seed[43])]; row[offsets.auxiliaries + 40] = v_46.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(124, v_14)) }, } }, _ => { Err(no_match(124, v_3)) }, } } + +static SCHEMA_124: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 16, 20, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 24, 28, 54, 55, 56, 57, 58, 59, 60, 61, 32, 36, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 8, 40], bytes: 80 }; + +fn pack_129(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.load::<10>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed[12] = v_12.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_14, v_15]: [G; 2] = context.call::<2>(8, 129, &[v_10])?; seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.call::<1>(9, 3, &[v_15])?; seed[14] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(11, &[v_17, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14])?; seed[15] = v_18.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(129, v_1)) }, } } + +fn pack_129_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(36, v_1); seed.u8(37, v_2); seed.u8(38, v_3); seed.u8(39, v_4); seed.u8(40, v_5); seed.u8(41, v_6); seed.u8(42, v_7); seed.u8(43, v_8); seed.u8(44, v_9); seed.u32(20, v_10); match v_1.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed.u32(24, v_12); Ok(()) }, 0u64 => { let [v_14, v_15]: [G; 2] = context.call::<2>(8, 129, &[v_10])?; seed.u32(24, v_14); seed.u32(28, v_15); let [v_16]: [G; 1] = context.call::<1>(9, 3, &[v_15])?; seed.full(8, v_16); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(11, &[v_17, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14])?; seed.u32(32, v_18); Ok(()) }, _ => { Err(no_match(129, v_1)) }, } } + +fn pack_129_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.load::<10>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed[12] = v_12.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_14, v_15]: [G; 2] = context.call::<2>(8, 129, &[v_10])?; seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.call::<1>(9, 3, &[v_15])?; seed[14] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(11, &[v_17, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14])?; seed[15] = v_18.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(129, v_1)) }, } } + +fn write_129(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_14, v_15]: [G; 2] = [G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 14] = v_18.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(129, v_1)) }, } } + +static SCHEMA_129: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 16, 36, 37, 38, 39, 40, 41, 42, 43, 44, 20, 24, 28, 8, 32], bytes: 48 }; + +fn pack_137(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_5]: [G; 1] = context.returned::<1>(3)?; seed[4] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_137_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed.u32(24, v_3); let [v_5]: [G; 1] = context.returned::<1>(3)?; seed.full(8, v_5); Ok(()) } + +fn pack_137_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.check_returned::<1>(3, 138, &[v_0, v_1, v_3, v_4])?; seed[4] = v_5.as_canonical_u64(); Ok(()) } + +fn write_137(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_137: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 16, 20, 24, 8], bytes: 32 }; + +fn pack_139(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 10] = context.load::<10>(0, v_8)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = context.call::<1>(1, 7, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[28] = v_27.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(3, &[v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed[29] = v_29.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(6, &[v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31])?; seed[29] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = context.store(7, &[v_30, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_32])?; seed[30] = v_33.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(139, v_27)) }, } }, 0u64 => { let [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]: [G; 16] = context.call::<16>(8, 135, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25])?; seed[28] = v_34.as_canonical_u64(); seed[29] = v_35.as_canonical_u64(); seed[30] = v_36.as_canonical_u64(); seed[31] = v_37.as_canonical_u64(); seed[32] = v_38.as_canonical_u64(); seed[33] = v_39.as_canonical_u64(); seed[34] = v_40.as_canonical_u64(); seed[35] = v_41.as_canonical_u64(); seed[36] = v_42.as_canonical_u64(); seed[37] = v_43.as_canonical_u64(); seed[38] = v_44.as_canonical_u64(); seed[39] = v_45.as_canonical_u64(); seed[40] = v_46.as_canonical_u64(); seed[41] = v_47.as_canonical_u64(); seed[42] = v_48.as_canonical_u64(); seed[43] = v_49.as_canonical_u64(); let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58]: [G; 9] = context.call::<9>(9, 16, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[44] = v_50.as_canonical_u64(); seed[45] = v_51.as_canonical_u64(); seed[46] = v_52.as_canonical_u64(); seed[47] = v_53.as_canonical_u64(); seed[48] = v_54.as_canonical_u64(); seed[49] = v_55.as_canonical_u64(); seed[50] = v_56.as_canonical_u64(); seed[51] = v_57.as_canonical_u64(); seed[52] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = context.call::<1>(11, 139, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed[53] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = context.store(12, &[v_59, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_60])?; seed[54] = v_61.as_canonical_u64(); Ok(()) }, _ => { let [v_62]: [G; 1] = [G::from_u64(0)]; let [v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70]: [G; 8] = context.call::<8>(14, 17, &[v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed[53] = v_63.as_canonical_u64(); seed[54] = v_64.as_canonical_u64(); seed[55] = v_65.as_canonical_u64(); seed[56] = v_66.as_canonical_u64(); seed[57] = v_67.as_canonical_u64(); seed[58] = v_68.as_canonical_u64(); seed[59] = v_69.as_canonical_u64(); seed[60] = v_70.as_canonical_u64(); let [v_71]: [G; 1] = context.call::<1>(15, 139, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70])?; seed[61] = v_71.as_canonical_u64(); let [v_72]: [G; 1] = context.store(16, &[v_62, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_71])?; seed[62] = v_72.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(139, v_17)) }, } } + +fn pack_139_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 10] = context.load::<10>(0, v_8)?; seed.u8(176, v_17); seed.full(72, v_18); seed.full(80, v_19); seed.full(88, v_20); seed.full(96, v_21); seed.full(104, v_22); seed.full(112, v_23); seed.full(120, v_24); seed.full(128, v_25); seed.u32(140, v_26); match v_17.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = context.call::<1>(1, 7, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u8(177, v_27); match v_27.as_canonical_u64() { 1u64 => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(3, &[v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed.u32(144, v_29); Ok(()) }, 0u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(6, &[v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31])?; seed.u32(144, v_32); let [v_33]: [G; 1] = context.store(7, &[v_30, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_32])?; seed.u32(148, v_33); Ok(()) }, _ => { Err(no_match(139, v_27)) }, } }, 0u64 => { let [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]: [G; 16] = context.call::<16>(8, 135, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25])?; seed.u8(177, v_34); seed.u32(144, v_35); seed.u32(148, v_36); seed.u8(178, v_37); seed.u8(179, v_38); seed.u8(180, v_39); seed.u8(181, v_40); seed.u8(182, v_41); seed.u8(183, v_42); seed.u8(184, v_43); seed.u8(185, v_44); seed.u8(186, v_45); seed.u8(187, v_46); seed.u8(188, v_47); seed.u8(189, v_48); seed.u8(190, v_49); let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58]: [G; 9] = context.call::<9>(9, 16, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u8(191, v_50); seed.u8(192, v_51); seed.u8(193, v_52); seed.u8(194, v_53); seed.u8(195, v_54); seed.u8(196, v_55); seed.u8(197, v_56); seed.u8(198, v_57); seed.u8(199, v_58); match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = context.call::<1>(11, 139, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed.u32(152, v_60); let [v_61]: [G; 1] = context.store(12, &[v_59, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_60])?; seed.u32(156, v_61); Ok(()) }, _ => { let [v_62]: [G; 1] = [G::from_u64(0)]; let [v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70]: [G; 8] = context.call::<8>(14, 17, &[v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed.u32(152, v_63); seed.u32(156, v_64); seed.u8(200, v_65); seed.u8(201, v_66); seed.u8(202, v_67); seed.u8(203, v_68); seed.u8(204, v_69); seed.u8(205, v_70); let [v_71]: [G; 1] = context.call::<1>(15, 139, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70])?; seed.u32(160, v_71); let [v_72]: [G; 1] = context.store(16, &[v_62, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_71])?; seed.u32(164, v_72); Ok(()) }, } }, _ => { Err(no_match(139, v_17)) }, } } + +fn pack_139_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 10] = context.load::<10>(0, v_8)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = context.call::<1>(1, 7, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[28] = v_27.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(3, &[v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed[29] = v_29.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(6, &[v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31])?; seed[29] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = context.store(7, &[v_30, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_32])?; seed[30] = v_33.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(139, v_27)) }, } }, 0u64 => { let [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]: [G; 16] = context.call::<16>(8, 135, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25])?; seed[28] = v_34.as_canonical_u64(); seed[29] = v_35.as_canonical_u64(); seed[30] = v_36.as_canonical_u64(); seed[31] = v_37.as_canonical_u64(); seed[32] = v_38.as_canonical_u64(); seed[33] = v_39.as_canonical_u64(); seed[34] = v_40.as_canonical_u64(); seed[35] = v_41.as_canonical_u64(); seed[36] = v_42.as_canonical_u64(); seed[37] = v_43.as_canonical_u64(); seed[38] = v_44.as_canonical_u64(); seed[39] = v_45.as_canonical_u64(); seed[40] = v_46.as_canonical_u64(); seed[41] = v_47.as_canonical_u64(); seed[42] = v_48.as_canonical_u64(); seed[43] = v_49.as_canonical_u64(); let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58]: [G; 9] = context.call::<9>(9, 16, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[44] = v_50.as_canonical_u64(); seed[45] = v_51.as_canonical_u64(); seed[46] = v_52.as_canonical_u64(); seed[47] = v_53.as_canonical_u64(); seed[48] = v_54.as_canonical_u64(); seed[49] = v_55.as_canonical_u64(); seed[50] = v_56.as_canonical_u64(); seed[51] = v_57.as_canonical_u64(); seed[52] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = context.call::<1>(11, 139, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed[53] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = context.store(12, &[v_59, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_60])?; seed[54] = v_61.as_canonical_u64(); Ok(()) }, _ => { let [v_62]: [G; 1] = [G::from_u64(0)]; let [v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70]: [G; 8] = context.call::<8>(14, 17, &[v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed[53] = v_63.as_canonical_u64(); seed[54] = v_64.as_canonical_u64(); seed[55] = v_65.as_canonical_u64(); seed[56] = v_66.as_canonical_u64(); seed[57] = v_67.as_canonical_u64(); seed[58] = v_68.as_canonical_u64(); seed[59] = v_69.as_canonical_u64(); seed[60] = v_70.as_canonical_u64(); let [v_71]: [G; 1] = context.call::<1>(15, 139, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70])?; seed[61] = v_71.as_canonical_u64(); let [v_72]: [G; 1] = context.store(16, &[v_62, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_71])?; seed[62] = v_72.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(139, v_17)) }, } } + +fn write_139(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 10] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27])]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_26.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 11] = v_27.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_29]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_32]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 12] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 13] = v_33.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(139, v_27)) }, } }, 0u64 => { let [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]: [G; 16] = [G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 11] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_49.as_canonical_u64(); let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58]: [G; 9] = [G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 27] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_60]: [G; 1] = [G::from_u64(seed[53])]; row[offsets.auxiliaries + 36] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_u64(seed[54])]; row[offsets.auxiliaries + 37] = v_61.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 36] = (v_58 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70]: [G; 8] = [G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 37] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_70.as_canonical_u64(); let [v_71]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 45] = v_71.as_canonical_u64(); let [v_72]: [G; 1] = [G::from_u64(seed[62])]; row[offsets.auxiliaries + 46] = v_72.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(139, v_17)) }, } } + +static SCHEMA_139: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 64, 136, 168, 169, 170, 171, 172, 173, 174, 175, 176, 72, 80, 88, 96, 104, 112, 120, 128, 140, 177, 144, 148, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 152, 156, 200, 201, 202, 203, 204, 205, 160, 164], bytes: 208 }; + +fn pack_227(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 214, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 215, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 216, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 221, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 222, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 223, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 225, &[])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed[15] = v_20.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } }, } } + +fn pack_227_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 214, &[])?; seed.u32(12, v_1); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed.u8(40, v_2); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 215, &[])?; seed.u32(16, v_4); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed.u8(41, v_5); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 216, &[])?; seed.u32(20, v_7); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed.u8(42, v_8); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 221, &[])?; seed.u32(24, v_10); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed.u8(43, v_11); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 222, &[])?; seed.u32(28, v_13); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed.u8(44, v_14); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 223, &[])?; seed.u32(32, v_16); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed.u8(45, v_17); match v_17.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 225, &[])?; seed.u32(36, v_19); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed.u8(46, v_20); Ok(()) }, } }, } }, } }, } }, } }, } } + +fn pack_227_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 214, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 215, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 216, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 221, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 222, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 223, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 225, &[])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed[15] = v_20.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } }, } } + +fn write_227(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_2 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 6] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 9] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 15] = (v_14 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 18] = (v_17 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 21] = (v_20 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, } }, } }, } }, } }, } }, } } + +static SCHEMA_227: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 40, 16, 41, 20, 42, 24, 43, 28, 44, 32, 45, 36, 46], bytes: 48 }; + +fn pack_263(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(3)]; let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_5, v_0, v_3, v_6])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.returned::<1>(4)?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(263, v_2)) }, } } + +fn pack_263_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(44, v_2); seed.full(16, v_3); seed.u32(36, v_4); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(3)]; let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_5, v_0, v_3, v_6])?; seed.u32(40, v_7); let [v_8]: [G; 1] = context.returned::<1>(4)?; seed.full(24, v_8); Ok(()) }, _ => { Err(no_match(263, v_2)) }, } } + +fn pack_263_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(3)]; let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_5, v_0, v_3, v_6])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.check_returned::<1>(4, 263, &[v_7, v_4])?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(263, v_2)) }, } } + +fn write_263(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(263, v_2)) }, } } + +static SCHEMA_263: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 8, 32, 44, 16, 36, 40, 24], bytes: 48 }; + +fn pack_349(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_10]: [G; 1] = context.call::<1>(6, 349, &[v_2])?; seed[6] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(7, 349, &[v_3])?; seed[7] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = context.returned::<1>(8)?; seed[8] = v_12.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_13]: [G; 1] = context.call::<1>(9, 349, &[v_2])?; seed[6] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(10, 349, &[v_3])?; seed[7] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = context.call::<1>(11, 352, &[v_14])?; seed[8] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.returned::<1>(12)?; seed[9] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.call::<1>(13, 349, &[v_2])?; seed[6] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(14, 349, &[v_3])?; seed[7] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(15, 352, &[v_18])?; seed[8] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.returned::<1>(16)?; seed[9] = v_20.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_21]: [G; 1] = context.returned::<1>(17)?; seed[6] = v_21.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_22]: [G; 1] = context.returned::<1>(18)?; seed[6] = v_22.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(349, v_1)) }, } } + +fn pack_349_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(56, v_1); seed.u32(44, v_2); seed.u32(48, v_3); seed.u32(52, v_4); match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_10]: [G; 1] = context.call::<1>(6, 349, &[v_2])?; seed.full(8, v_10); let [v_11]: [G; 1] = context.call::<1>(7, 349, &[v_3])?; seed.full(16, v_11); let [v_12]: [G; 1] = context.returned::<1>(8)?; seed.full(24, v_12); Ok(()) }, 4u64 => { let [v_13]: [G; 1] = context.call::<1>(9, 349, &[v_2])?; seed.full(8, v_13); let [v_14]: [G; 1] = context.call::<1>(10, 349, &[v_3])?; seed.full(16, v_14); let [v_15]: [G; 1] = context.call::<1>(11, 352, &[v_14])?; seed.full(24, v_15); let [v_16]: [G; 1] = context.returned::<1>(12)?; seed.full(32, v_16); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.call::<1>(13, 349, &[v_2])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(14, 349, &[v_3])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(15, 352, &[v_18])?; seed.full(24, v_19); let [v_20]: [G; 1] = context.returned::<1>(16)?; seed.full(32, v_20); Ok(()) }, 6u64 => { let [v_21]: [G; 1] = context.returned::<1>(17)?; seed.full(8, v_21); Ok(()) }, 8u64 => { let [v_22]: [G; 1] = context.returned::<1>(18)?; seed.full(8, v_22); Ok(()) }, _ => { Err(no_match(349, v_1)) }, } } + +fn pack_349_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_10]: [G; 1] = context.call::<1>(6, 349, &[v_2])?; seed[6] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(7, 349, &[v_3])?; seed[7] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = context.check_returned::<1>(8, 351, &[v_10, v_11])?; seed[8] = v_12.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_13]: [G; 1] = context.call::<1>(9, 349, &[v_2])?; seed[6] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(10, 349, &[v_3])?; seed[7] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = context.call::<1>(11, 352, &[v_14])?; seed[8] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.check_returned::<1>(12, 351, &[v_13, v_15])?; seed[9] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.call::<1>(13, 349, &[v_2])?; seed[6] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(14, 349, &[v_3])?; seed[7] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(15, 352, &[v_18])?; seed[8] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.check_returned::<1>(16, 351, &[v_17, v_19])?; seed[9] = v_20.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_21]: [G; 1] = context.check_returned::<1>(17, 350, &[v_2, v_3, v_4])?; seed[6] = v_21.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_22]: [G; 1] = context.check_returned::<1>(18, 349, &[v_4])?; seed[6] = v_22.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(349, v_1)) }, } } + +fn write_349(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4]: [G; 4] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 8] = v_20.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_21]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_22]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(349, v_1)) }, } } + +static SCHEMA_349: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 40, 56, 44, 48, 52, 8, 16, 24, 32], bytes: 64 }; + +fn pack_354(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_13]: [G; 1] = context.call::<1>(7, 354, &[v_4, v_1, v_2])?; seed[8] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_15]: [G; 1] = context.returned::<1>(9)?; seed[9] = v_15.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(354, v_13)) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(10)?; seed[8] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(11)?; seed[8] = v_17.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(12)?; seed[8] = v_18.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(13)?; seed[8] = v_19.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(354, v_3)) }, } } + +fn pack_354_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(32, v_3); seed.u32(20, v_4); seed.u32(24, v_5); seed.u32(28, v_6); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_13]: [G; 1] = context.call::<1>(7, 354, &[v_4, v_1, v_2])?; seed.u8(33, v_13); match v_13.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_15]: [G; 1] = context.returned::<1>(9)?; seed.u8(34, v_15); Ok(()) }, _ => { Err(no_match(354, v_13)) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(10)?; seed.u8(33, v_16); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(11)?; seed.u8(33, v_17); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(12)?; seed.u8(33, v_18); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(13)?; seed.u8(33, v_19); Ok(()) }, _ => { Err(no_match(354, v_3)) }, } } + +fn pack_354_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_13]: [G; 1] = context.call::<1>(7, 354, &[v_4, v_1, v_2])?; seed[8] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_15]: [G; 1] = context.check_returned::<1>(9, 354, &[v_5, v_1, v_2])?; seed[9] = v_15.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(354, v_13)) }, } }, 4u64 => { let [v_16]: [G; 1] = context.check_returned::<1>(10, 355, &[v_4, v_5, v_1, v_2])?; seed[8] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.check_returned::<1>(11, 355, &[v_4, v_5, v_1, v_2])?; seed[8] = v_17.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.check_returned::<1>(12, 356, &[v_4, v_5, v_6, v_1, v_2])?; seed[8] = v_18.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.check_returned::<1>(13, 354, &[v_6, v_1, v_2])?; seed[8] = v_19.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(354, v_3)) }, } } + +fn write_354(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6]: [G; 4] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_1); let [v_7]: [G; 1] = [op_1.0]; row[offsets.auxiliaries + 5] = op_1.1[0].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_1.1[1].as_canonical_u64(); row[offsets.auxiliaries + 7] = op_1.1[2].as_canonical_u64(); row[offsets.auxiliaries + 8] = op_1.1[3].as_canonical_u64(); row[offsets.auxiliaries + 9] = op_1.1[4].as_canonical_u64(); row[offsets.auxiliaries + 10] = op_1.1[5].as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let op_3 = u32_less_than(v_4, v_2); let [v_9]: [G; 1] = [op_3.0]; row[offsets.auxiliaries + 11] = op_3.1[0].as_canonical_u64(); row[offsets.auxiliaries + 12] = op_3.1[1].as_canonical_u64(); row[offsets.auxiliaries + 13] = op_3.1[2].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_3.1[3].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_3.1[4].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_3.1[5].as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(354, v_7)) }, } }, 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(354, v_13)) }, } }, 4u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_18.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(354, v_3)) }, } } + +static SCHEMA_354: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 16, 32, 20, 24, 28, 33, 34], bytes: 40 }; + +fn pack_362(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 349, &[v_0])?; seed[3] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = [G::from_u64(1)]; let [v_4]: [G; 1] = [v_1 + v_3]; let [v_5]: [G; 1] = context.call::<1>(3, 0, &[v_2, v_4])?; seed[4] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.returned::<1>(5)?; seed[5] = v_7.as_canonical_u64(); Ok(()) }, } } + +fn pack_362_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 349, &[v_0])?; seed.u32(24, v_2); let [v_3]: [G; 1] = [G::from_u64(1)]; let [v_4]: [G; 1] = [v_1 + v_3]; let [v_5]: [G; 1] = context.call::<1>(3, 0, &[v_2, v_4])?; seed.u8(28, v_5); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.returned::<1>(5)?; seed.full(8, v_7); Ok(()) }, } } + +fn pack_362_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 349, &[v_0])?; seed[3] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = [G::from_u64(1)]; let [v_4]: [G; 1] = [v_1 + v_3]; let [v_5]: [G; 1] = context.call::<1>(3, 0, &[v_2, v_4])?; seed[4] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.check_returned::<1>(5, 363, &[v_0, v_1])?; seed[5] = v_7.as_canonical_u64(); Ok(()) }, } } + +fn write_362(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_362: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 16, 20, 24, 28, 8], bytes: 32 }; + +fn pack_363(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 0, &[v_3, v_1])?; seed[7] = v_6.as_canonical_u64(); Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_12]: [G; 1] = context.call::<1>(7, 362, &[v_3, v_1])?; seed[7] = v_12.as_canonical_u64(); match v_12.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_14]: [G; 1] = context.call::<1>(9, 362, &[v_4, v_1])?; seed[8] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = context.returned::<1>(10)?; seed[9] = v_15.as_canonical_u64(); Ok(()) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(11)?; seed[7] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(12)?; seed[7] = v_17.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(13)?; seed[7] = v_18.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(14)?; seed[7] = v_19.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(363, v_2)) }, } } + +fn pack_363_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(48, v_2); seed.u32(32, v_3); seed.u32(36, v_4); seed.u32(40, v_5); match v_2.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 0, &[v_3, v_1])?; seed.full(8, v_6); Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_12]: [G; 1] = context.call::<1>(7, 362, &[v_3, v_1])?; seed.full(8, v_12); match v_12.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_14]: [G; 1] = context.call::<1>(9, 362, &[v_4, v_1])?; seed.u32(44, v_14); let [v_15]: [G; 1] = context.returned::<1>(10)?; seed.full(16, v_15); Ok(()) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(11)?; seed.full(8, v_16); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(12)?; seed.full(8, v_17); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(13)?; seed.full(8, v_18); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(14)?; seed.full(8, v_19); Ok(()) }, _ => { Err(no_match(363, v_2)) }, } } + +fn pack_363_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 0, &[v_3, v_1])?; seed[7] = v_6.as_canonical_u64(); Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_12]: [G; 1] = context.call::<1>(7, 362, &[v_3, v_1])?; seed[7] = v_12.as_canonical_u64(); match v_12.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_14]: [G; 1] = context.call::<1>(9, 362, &[v_4, v_1])?; seed[8] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = context.check_returned::<1>(10, 353, &[v_12, v_14])?; seed[9] = v_15.as_canonical_u64(); Ok(()) }, } }, 4u64 => { let [v_16]: [G; 1] = context.check_returned::<1>(11, 364, &[v_3, v_4, v_1])?; seed[7] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.check_returned::<1>(12, 364, &[v_3, v_4, v_1])?; seed[7] = v_17.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.check_returned::<1>(13, 365, &[v_3, v_4, v_5, v_1])?; seed[7] = v_18.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.check_returned::<1>(14, 362, &[v_5, v_1])?; seed[7] = v_19.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(363, v_2)) }, } } + +fn write_363(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5]: [G; 4] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); match v_6.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(363, v_6)) }, } }, 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); match v_12.as_canonical_u64() { 0u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 6] = (v_12 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 4u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_18.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(363, v_2)) }, } } + +static SCHEMA_363: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 24, 28, 48, 32, 36, 40, 8, 44, 16], bytes: 56 }; + +fn pack_370(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3]: [G; 1] = context.call::<1>(0, 349, &[v_0])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.call::<1>(1, 0, &[v_2, v_3])?; seed[5] = v_4.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed[6] = v_5.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(370, v_4)) }, } }, } } + +fn pack_370_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3]: [G; 1] = context.call::<1>(0, 349, &[v_0])?; seed.u32(32, v_3); let [v_4]: [G; 1] = context.call::<1>(1, 0, &[v_2, v_3])?; seed.u8(36, v_4); match v_4.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed.full(16, v_5); Ok(()) }, _ => { Err(no_match(370, v_4)) }, } }, } } + +fn pack_370_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3]: [G; 1] = context.call::<1>(0, 349, &[v_0])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.call::<1>(1, 0, &[v_2, v_3])?; seed[5] = v_4.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_5]: [G; 1] = context.check_returned::<1>(2, 371, &[v_0, v_1, v_2])?; seed[6] = v_5.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(370, v_4)) }, } }, } } + +fn write_370(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_5]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(370, v_4)) }, } }, } } + +static SCHEMA_370: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 8, 28, 32, 36, 16], bytes: 40 }; + +fn pack_371(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_2); let [v_7]: [G; 1] = [op_1.0]; match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = [v_4 - v_1]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_9, v_8, v_8])?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(371, v_7)) }, } }, 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_12, v_12])?; seed[8] = v_13.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_14]: [G; 1] = [G::from_u64(2)]; let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.store(10, &[v_14, v_4, v_5, v_15])?; seed[8] = v_16.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_17]: [G; 1] = [G::from_u64(3)]; let [v_18]: [G; 1] = context.call::<1>(12, 370, &[v_4, v_1, v_2])?; seed[8] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(13, 370, &[v_5, v_1, v_2])?; seed[9] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = context.store(15, &[v_17, v_18, v_19, v_20])?; seed[10] = v_21.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_22]: [G; 1] = [G::from_u64(4)]; let [v_23]: [G; 1] = context.call::<1>(17, 370, &[v_4, v_1, v_2])?; seed[8] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_2 + v_24]; let [v_26]: [G; 1] = context.call::<1>(20, 370, &[v_5, v_1, v_25])?; seed[9] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(0)]; let [v_28]: [G; 1] = context.store(22, &[v_22, v_23, v_26, v_27])?; seed[10] = v_28.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_29]: [G; 1] = [G::from_u64(5)]; let [v_30]: [G; 1] = context.call::<1>(24, 370, &[v_4, v_1, v_2])?; seed[8] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = [v_2 + v_31]; let [v_33]: [G; 1] = context.call::<1>(27, 370, &[v_5, v_1, v_32])?; seed[9] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35]: [G; 1] = context.store(29, &[v_29, v_30, v_33, v_34])?; seed[10] = v_35.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_36]: [G; 1] = [G::from_u64(6)]; let [v_37]: [G; 1] = context.call::<1>(31, 370, &[v_4, v_1, v_2])?; seed[8] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = context.call::<1>(32, 370, &[v_5, v_1, v_2])?; seed[9] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(1)]; let [v_40]: [G; 1] = [v_2 + v_39]; let [v_41]: [G; 1] = context.call::<1>(35, 370, &[v_6, v_1, v_40])?; seed[10] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.store(36, &[v_36, v_37, v_38, v_41])?; seed[11] = v_42.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_43]: [G; 1] = [G::from_u64(7)]; let [v_44]: [G; 1] = [G::from_u64(0)]; let [v_45]: [G; 1] = context.store(39, &[v_43, v_4, v_5, v_44])?; seed[8] = v_45.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_46]: [G; 1] = [G::from_u64(8)]; let [v_47]: [G; 1] = context.call::<1>(41, 370, &[v_6, v_1, v_2])?; seed[8] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = context.store(42, &[v_46, v_4, v_5, v_47])?; seed[9] = v_48.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(371, v_3)) }, } } + +fn pack_371_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(64, v_3); seed.u32(48, v_4); seed.u32(52, v_5); seed.u32(56, v_6); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_2); let [v_7]: [G; 1] = [op_1.0]; match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = [v_4 - v_1]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_9, v_8, v_8])?; seed.full(16, v_10); Ok(()) }, _ => { Err(no_match(371, v_7)) }, } }, 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_12, v_12])?; seed.full(16, v_13); Ok(()) }, 2u64 => { let [v_14]: [G; 1] = [G::from_u64(2)]; let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.store(10, &[v_14, v_4, v_5, v_15])?; seed.full(16, v_16); Ok(()) }, 3u64 => { let [v_17]: [G; 1] = [G::from_u64(3)]; let [v_18]: [G; 1] = context.call::<1>(12, 370, &[v_4, v_1, v_2])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(13, 370, &[v_5, v_1, v_2])?; seed.full(24, v_19); let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = context.store(15, &[v_17, v_18, v_19, v_20])?; seed.full(32, v_21); Ok(()) }, 4u64 => { let [v_22]: [G; 1] = [G::from_u64(4)]; let [v_23]: [G; 1] = context.call::<1>(17, 370, &[v_4, v_1, v_2])?; seed.full(16, v_23); let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_2 + v_24]; let [v_26]: [G; 1] = context.call::<1>(20, 370, &[v_5, v_1, v_25])?; seed.full(24, v_26); let [v_27]: [G; 1] = [G::from_u64(0)]; let [v_28]: [G; 1] = context.store(22, &[v_22, v_23, v_26, v_27])?; seed.full(32, v_28); Ok(()) }, 5u64 => { let [v_29]: [G; 1] = [G::from_u64(5)]; let [v_30]: [G; 1] = context.call::<1>(24, 370, &[v_4, v_1, v_2])?; seed.full(16, v_30); let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = [v_2 + v_31]; let [v_33]: [G; 1] = context.call::<1>(27, 370, &[v_5, v_1, v_32])?; seed.full(24, v_33); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35]: [G; 1] = context.store(29, &[v_29, v_30, v_33, v_34])?; seed.full(32, v_35); Ok(()) }, 6u64 => { let [v_36]: [G; 1] = [G::from_u64(6)]; let [v_37]: [G; 1] = context.call::<1>(31, 370, &[v_4, v_1, v_2])?; seed.full(16, v_37); let [v_38]: [G; 1] = context.call::<1>(32, 370, &[v_5, v_1, v_2])?; seed.full(24, v_38); let [v_39]: [G; 1] = [G::from_u64(1)]; let [v_40]: [G; 1] = [v_2 + v_39]; let [v_41]: [G; 1] = context.call::<1>(35, 370, &[v_6, v_1, v_40])?; seed.full(32, v_41); let [v_42]: [G; 1] = context.store(36, &[v_36, v_37, v_38, v_41])?; seed.u32(60, v_42); Ok(()) }, 7u64 => { let [v_43]: [G; 1] = [G::from_u64(7)]; let [v_44]: [G; 1] = [G::from_u64(0)]; let [v_45]: [G; 1] = context.store(39, &[v_43, v_4, v_5, v_44])?; seed.full(16, v_45); Ok(()) }, 8u64 => { let [v_46]: [G; 1] = [G::from_u64(8)]; let [v_47]: [G; 1] = context.call::<1>(41, 370, &[v_6, v_1, v_2])?; seed.full(16, v_47); let [v_48]: [G; 1] = context.store(42, &[v_46, v_4, v_5, v_47])?; seed.full(24, v_48); Ok(()) }, _ => { Err(no_match(371, v_3)) }, } } + +fn pack_371_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_2); let [v_7]: [G; 1] = [op_1.0]; match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = [v_4 - v_1]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_9, v_8, v_8])?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(371, v_7)) }, } }, 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_12, v_12])?; seed[8] = v_13.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_14]: [G; 1] = [G::from_u64(2)]; let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.store(10, &[v_14, v_4, v_5, v_15])?; seed[8] = v_16.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_17]: [G; 1] = [G::from_u64(3)]; let [v_18]: [G; 1] = context.call::<1>(12, 370, &[v_4, v_1, v_2])?; seed[8] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(13, 370, &[v_5, v_1, v_2])?; seed[9] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = context.store(15, &[v_17, v_18, v_19, v_20])?; seed[10] = v_21.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_22]: [G; 1] = [G::from_u64(4)]; let [v_23]: [G; 1] = context.call::<1>(17, 370, &[v_4, v_1, v_2])?; seed[8] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_2 + v_24]; let [v_26]: [G; 1] = context.call::<1>(20, 370, &[v_5, v_1, v_25])?; seed[9] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(0)]; let [v_28]: [G; 1] = context.store(22, &[v_22, v_23, v_26, v_27])?; seed[10] = v_28.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_29]: [G; 1] = [G::from_u64(5)]; let [v_30]: [G; 1] = context.call::<1>(24, 370, &[v_4, v_1, v_2])?; seed[8] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = [v_2 + v_31]; let [v_33]: [G; 1] = context.call::<1>(27, 370, &[v_5, v_1, v_32])?; seed[9] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35]: [G; 1] = context.store(29, &[v_29, v_30, v_33, v_34])?; seed[10] = v_35.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_36]: [G; 1] = [G::from_u64(6)]; let [v_37]: [G; 1] = context.call::<1>(31, 370, &[v_4, v_1, v_2])?; seed[8] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = context.call::<1>(32, 370, &[v_5, v_1, v_2])?; seed[9] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(1)]; let [v_40]: [G; 1] = [v_2 + v_39]; let [v_41]: [G; 1] = context.call::<1>(35, 370, &[v_6, v_1, v_40])?; seed[10] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.store(36, &[v_36, v_37, v_38, v_41])?; seed[11] = v_42.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_43]: [G; 1] = [G::from_u64(7)]; let [v_44]: [G; 1] = [G::from_u64(0)]; let [v_45]: [G; 1] = context.store(39, &[v_43, v_4, v_5, v_44])?; seed[8] = v_45.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_46]: [G; 1] = [G::from_u64(8)]; let [v_47]: [G; 1] = context.call::<1>(41, 370, &[v_6, v_1, v_2])?; seed[8] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = context.store(42, &[v_46, v_4, v_5, v_47])?; seed[9] = v_48.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(371, v_3)) }, } } + +fn write_371(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6]: [G; 4] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_2); let [v_7]: [G; 1] = [op_1.0]; row[offsets.auxiliaries + 5] = op_1.1[0].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_1.1[1].as_canonical_u64(); row[offsets.auxiliaries + 7] = op_1.1[2].as_canonical_u64(); row[offsets.auxiliaries + 8] = op_1.1[3].as_canonical_u64(); row[offsets.auxiliaries + 9] = op_1.1[4].as_canonical_u64(); row[offsets.auxiliaries + 10] = op_1.1[5].as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 11] = v_10.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(371, v_7)) }, } }, 1u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_19.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_21.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_23]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_26.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_28.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_30]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_30.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_33.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_35.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_37]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_38.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_42.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_45]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_45.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_47]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_48.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(371, v_3)) }, } } + +static SCHEMA_371: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 40, 8, 44, 64, 48, 52, 56, 16, 24, 32, 60], bytes: 72 }; + +fn pack_377(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 0, &[v_0, v_2])?; seed[4] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.store(2, &[v_4, v_0, v_4, v_4])?; seed[5] = v_5.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_0 - v_2]; match v_6.as_canonical_u64() { 0u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed[5] = v_8.as_canonical_u64(); Ok(()) }, _ => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = [v_0 - v_10]; let [v_12]: [G; 1] = context.store(9, &[v_9, v_11, v_9, v_9])?; seed[5] = v_12.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(377, v_3)) }, } } + +fn pack_377_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 0, &[v_0, v_2])?; seed.u8(28, v_3); match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.store(2, &[v_4, v_0, v_4, v_4])?; seed.full(8, v_5); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_0 - v_2]; match v_6.as_canonical_u64() { 0u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed.full(8, v_8); Ok(()) }, _ => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = [v_0 - v_10]; let [v_12]: [G; 1] = context.store(9, &[v_9, v_11, v_9, v_9])?; seed.full(8, v_12); Ok(()) }, } }, _ => { Err(no_match(377, v_3)) }, } } + +fn pack_377_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 0, &[v_0, v_2])?; seed[4] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.store(2, &[v_4, v_0, v_4, v_4])?; seed[5] = v_5.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_0 - v_2]; match v_6.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(0)]; let [v_8]: [G; 1] = context.check_returned::<1>(5, 366, &[v_1, v_2, v_7])?; seed[5] = v_8.as_canonical_u64(); Ok(()) }, _ => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = [v_0 - v_10]; let [v_12]: [G; 1] = context.store(9, &[v_9, v_11, v_9, v_9])?; seed[5] = v_12.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(377, v_3)) }, } } + +fn write_377(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_0 - v_2]; match v_6.as_canonical_u64() { 0u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_8.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 2] = (v_6 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_12]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(377, v_3)) }, } } + +static SCHEMA_377: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 16, 20, 24, 28, 8], bytes: 32 }; + +fn pack_379(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 787, &[v_1])?; seed[4] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(1, 349, &[v_0])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_2, v_4])?; seed[6] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_6]: [G; 1] = [v_2 + v_3]; let [v_7]: [G; 1] = context.call::<1>(4, 354, &[v_0, v_2, v_6])?; seed[7] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed[8] = v_8.as_canonical_u64(); Ok(()) }, _ => { let [v_10]: [G; 1] = context.returned::<1>(7)?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(379, v_5)) }, } }, } } + +fn pack_379_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 787, &[v_1])?; seed.full(8, v_3); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(1, 349, &[v_0])?; seed.u32(36, v_4); let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_2, v_4])?; seed.u8(40, v_5); match v_5.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_6]: [G; 1] = [v_2 + v_3]; let [v_7]: [G; 1] = context.call::<1>(4, 354, &[v_0, v_2, v_6])?; seed.u8(41, v_7); match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed.full(16, v_8); Ok(()) }, _ => { let [v_10]: [G; 1] = context.returned::<1>(7)?; seed.full(16, v_10); Ok(()) }, } }, _ => { Err(no_match(379, v_5)) }, } }, } } + +fn pack_379_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 787, &[v_1])?; seed[4] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(1, 349, &[v_0])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_2, v_4])?; seed[6] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_6]: [G; 1] = [v_2 + v_3]; let [v_7]: [G; 1] = context.call::<1>(4, 354, &[v_0, v_2, v_6])?; seed[7] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.check_returned::<1>(5, 381, &[v_0, v_1, v_2])?; seed[8] = v_8.as_canonical_u64(); Ok(()) }, _ => { let [v_9]: [G; 1] = [v_2 + v_3]; let [v_10]: [G; 1] = context.check_returned::<1>(7, 370, &[v_0, v_3, v_9])?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(379, v_5)) }, } }, } } + +fn write_379(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 2] = (v_3 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 6] = (v_7 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(379, v_5)) }, } }, } } + +static SCHEMA_379: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 28, 32, 8, 36, 40, 41, 16], bytes: 48 }; + +fn pack_380(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 787, &[v_1])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [v_0 - v_2]; let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_4, v_3])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(3, 789, &[v_1, v_4])?; seed[6] = v_6.as_canonical_u64(); let [v_8]: [G; 1] = context.returned::<1>(5)?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [v_0 - v_3]; let [v_11]: [G; 1] = context.store(8, &[v_9, v_10, v_9, v_9])?; seed[6] = v_11.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(380, v_5)) }, } } + +fn pack_380_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 787, &[v_1])?; seed.u32(36, v_3); let [v_4]: [G; 1] = [v_0 - v_2]; let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_4, v_3])?; seed.u8(44, v_5); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(3, 789, &[v_1, v_4])?; seed.u32(40, v_6); let [v_8]: [G; 1] = context.returned::<1>(5)?; seed.full(24, v_8); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [v_0 - v_3]; let [v_11]: [G; 1] = context.store(8, &[v_9, v_10, v_9, v_9])?; seed.u32(40, v_11); Ok(()) }, _ => { Err(no_match(380, v_5)) }, } } + +fn pack_380_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 787, &[v_1])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [v_0 - v_2]; let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_4, v_3])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(3, 789, &[v_1, v_4])?; seed[6] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(0)]; let [v_8]: [G; 1] = context.check_returned::<1>(5, 366, &[v_6, v_2, v_7])?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [v_0 - v_3]; let [v_11]: [G; 1] = context.store(8, &[v_9, v_10, v_9, v_9])?; seed[6] = v_11.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(380, v_5)) }, } } + +fn write_380(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_8.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(380, v_5)) }, } } + +static SCHEMA_380: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 8, 32, 16, 36, 44, 40, 24], bytes: 48 }; + +fn pack_381(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = context.returned::<1>(1)?; seed[8] = v_7.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_4, v_9, v_9])?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_11]: [G; 1] = [G::from_u64(2)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_5, v_12])?; seed[8] = v_13.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_14]: [G; 1] = [G::from_u64(3)]; let [v_15]: [G; 1] = context.call::<1>(9, 379, &[v_4, v_1, v_2])?; seed[8] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.call::<1>(10, 379, &[v_5, v_1, v_2])?; seed[9] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(12, &[v_14, v_15, v_16, v_17])?; seed[10] = v_18.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_19]: [G; 1] = [G::from_u64(4)]; let [v_20]: [G; 1] = context.call::<1>(14, 379, &[v_4, v_1, v_2])?; seed[8] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(1)]; let [v_22]: [G; 1] = [v_2 + v_21]; let [v_23]: [G; 1] = context.call::<1>(17, 379, &[v_5, v_1, v_22])?; seed[9] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(19, &[v_19, v_20, v_23, v_24])?; seed[10] = v_25.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = context.call::<1>(21, 379, &[v_4, v_1, v_2])?; seed[8] = v_27.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = [v_2 + v_28]; let [v_30]: [G; 1] = context.call::<1>(24, 379, &[v_5, v_1, v_29])?; seed[9] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.store(26, &[v_26, v_27, v_30, v_31])?; seed[10] = v_32.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_33]: [G; 1] = context.returned::<1>(27)?; seed[8] = v_33.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_34]: [G; 1] = [G::from_u64(7)]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = context.store(30, &[v_34, v_4, v_5, v_35])?; seed[8] = v_36.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_37]: [G; 1] = [G::from_u64(8)]; let [v_38]: [G; 1] = context.call::<1>(32, 379, &[v_6, v_1, v_2])?; seed[8] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.store(33, &[v_37, v_4, v_5, v_38])?; seed[9] = v_39.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(381, v_3)) }, } } + +fn pack_381_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(52, v_3); seed.u32(36, v_4); seed.u32(40, v_5); seed.u32(44, v_6); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = context.returned::<1>(1)?; seed.full(8, v_7); Ok(()) }, 1u64 => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_4, v_9, v_9])?; seed.full(8, v_10); Ok(()) }, 2u64 => { let [v_11]: [G; 1] = [G::from_u64(2)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_5, v_12])?; seed.full(8, v_13); Ok(()) }, 3u64 => { let [v_14]: [G; 1] = [G::from_u64(3)]; let [v_15]: [G; 1] = context.call::<1>(9, 379, &[v_4, v_1, v_2])?; seed.full(8, v_15); let [v_16]: [G; 1] = context.call::<1>(10, 379, &[v_5, v_1, v_2])?; seed.full(16, v_16); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(12, &[v_14, v_15, v_16, v_17])?; seed.u32(48, v_18); Ok(()) }, 4u64 => { let [v_19]: [G; 1] = [G::from_u64(4)]; let [v_20]: [G; 1] = context.call::<1>(14, 379, &[v_4, v_1, v_2])?; seed.full(8, v_20); let [v_21]: [G; 1] = [G::from_u64(1)]; let [v_22]: [G; 1] = [v_2 + v_21]; let [v_23]: [G; 1] = context.call::<1>(17, 379, &[v_5, v_1, v_22])?; seed.full(16, v_23); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(19, &[v_19, v_20, v_23, v_24])?; seed.u32(48, v_25); Ok(()) }, 5u64 => { let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = context.call::<1>(21, 379, &[v_4, v_1, v_2])?; seed.full(8, v_27); let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = [v_2 + v_28]; let [v_30]: [G; 1] = context.call::<1>(24, 379, &[v_5, v_1, v_29])?; seed.full(16, v_30); let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.store(26, &[v_26, v_27, v_30, v_31])?; seed.u32(48, v_32); Ok(()) }, 6u64 => { let [v_33]: [G; 1] = context.returned::<1>(27)?; seed.full(8, v_33); Ok(()) }, 7u64 => { let [v_34]: [G; 1] = [G::from_u64(7)]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = context.store(30, &[v_34, v_4, v_5, v_35])?; seed.full(8, v_36); Ok(()) }, 8u64 => { let [v_37]: [G; 1] = [G::from_u64(8)]; let [v_38]: [G; 1] = context.call::<1>(32, 379, &[v_6, v_1, v_2])?; seed.full(8, v_38); let [v_39]: [G; 1] = context.store(33, &[v_37, v_4, v_5, v_38])?; seed.full(16, v_39); Ok(()) }, _ => { Err(no_match(381, v_3)) }, } } + +fn pack_381_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = context.check_returned::<1>(1, 380, &[v_4, v_1, v_2])?; seed[8] = v_7.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_4, v_9, v_9])?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_11]: [G; 1] = [G::from_u64(2)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_5, v_12])?; seed[8] = v_13.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_14]: [G; 1] = [G::from_u64(3)]; let [v_15]: [G; 1] = context.call::<1>(9, 379, &[v_4, v_1, v_2])?; seed[8] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.call::<1>(10, 379, &[v_5, v_1, v_2])?; seed[9] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(12, &[v_14, v_15, v_16, v_17])?; seed[10] = v_18.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_19]: [G; 1] = [G::from_u64(4)]; let [v_20]: [G; 1] = context.call::<1>(14, 379, &[v_4, v_1, v_2])?; seed[8] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(1)]; let [v_22]: [G; 1] = [v_2 + v_21]; let [v_23]: [G; 1] = context.call::<1>(17, 379, &[v_5, v_1, v_22])?; seed[9] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(19, &[v_19, v_20, v_23, v_24])?; seed[10] = v_25.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = context.call::<1>(21, 379, &[v_4, v_1, v_2])?; seed[8] = v_27.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = [v_2 + v_28]; let [v_30]: [G; 1] = context.call::<1>(24, 379, &[v_5, v_1, v_29])?; seed[9] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.store(26, &[v_26, v_27, v_30, v_31])?; seed[10] = v_32.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_33]: [G; 1] = context.check_returned::<1>(27, 382, &[v_4, v_5, v_6, v_1, v_2])?; seed[8] = v_33.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_34]: [G; 1] = [G::from_u64(7)]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = context.store(30, &[v_34, v_4, v_5, v_35])?; seed[8] = v_36.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_37]: [G; 1] = [G::from_u64(8)]; let [v_38]: [G; 1] = context.call::<1>(32, 379, &[v_6, v_1, v_2])?; seed[8] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.store(33, &[v_37, v_4, v_5, v_38])?; seed[9] = v_39.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(381, v_3)) }, } } + +fn write_381(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6]: [G; 4] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_16.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_18.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_27]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_27.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_32.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_33]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_33.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_36]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_36.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_39.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(381, v_3)) }, } } + +static SCHEMA_381: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 24, 28, 32, 52, 36, 40, 44, 8, 16, 48], bytes: 56 }; + +fn pack_393(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4]: [G; 1] = context.call::<1>(0, 387, &[])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_4])?; seed[6] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6, v_6])?; seed[7] = v_7.as_canonical_u64(); Ok(()) }, _ => { match v_1.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11]: [G; 4] = context.load::<4>(4, v_2)?; seed[7] = v_8.as_canonical_u64(); seed[8] = v_9.as_canonical_u64(); seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); match v_8.as_canonical_u64() { 2u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 388, &[])?; seed[11] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = context.call::<1>(6, 2, &[v_9, v_12])?; seed[12] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(8, &[v_14, v_14, v_14, v_14])?; seed[13] = v_15.as_canonical_u64(); Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(9, 787, &[v_3])?; seed[13] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(5)]; let op_11 = u32_less_than(v_16, v_17); let [v_18]: [G; 1] = [op_11.0]; match v_18.as_canonical_u64() { 1u64 => { let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(13, &[v_19, v_19, v_19, v_19])?; seed[14] = v_20.as_canonical_u64(); Ok(()) }, _ => { let [v_21]: [G; 1] = [G::from_u64(0)]; let [v_22]: [G; 1] = context.call::<1>(15, 789, &[v_3, v_21])?; seed[14] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.call::<1>(17, 789, &[v_3, v_23])?; seed[15] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(2)]; let [v_26]: [G; 1] = context.call::<1>(19, 789, &[v_3, v_25])?; seed[16] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(3)]; let [v_28]: [G; 1] = context.call::<1>(21, 789, &[v_3, v_27])?; seed[17] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(4)]; let [v_30]: [G; 1] = context.call::<1>(23, 789, &[v_3, v_29])?; seed[18] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34]: [G; 4] = context.load::<4>(24, v_24)?; seed[19] = v_31.as_canonical_u64(); seed[20] = v_32.as_canonical_u64(); seed[21] = v_33.as_canonical_u64(); seed[22] = v_34.as_canonical_u64(); match v_31.as_canonical_u64() { 4u64 => { let [v_35, v_36, v_37, v_38]: [G; 4] = context.load::<4>(25, v_26)?; seed[23] = v_35.as_canonical_u64(); seed[24] = v_36.as_canonical_u64(); seed[25] = v_37.as_canonical_u64(); seed[26] = v_38.as_canonical_u64(); match v_35.as_canonical_u64() { 4u64 => { let [v_39]: [G; 1] = [G::from_u64(8)]; let [v_40]: [G; 1] = context.store(27, &[v_39, v_0, v_1, v_37])?; seed[27] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(4)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(30, &[v_41, v_36, v_40, v_42])?; seed[28] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47]: [G; 4] = context.load::<4>(31, v_28)?; seed[29] = v_44.as_canonical_u64(); seed[30] = v_45.as_canonical_u64(); seed[31] = v_46.as_canonical_u64(); seed[32] = v_47.as_canonical_u64(); match v_44.as_canonical_u64() { 4u64 => { let [v_48]: [G; 1] = [G::from_u64(8)]; let [v_49]: [G; 1] = context.store(33, &[v_48, v_0, v_1, v_46])?; seed[33] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = [G::from_u64(4)]; let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.store(36, &[v_50, v_45, v_49, v_51])?; seed[34] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(2)]; let [v_54]: [G; 1] = context.call::<1>(38, 389, &[])?; seed[35] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.store(40, &[v_55, v_55, v_55])?; seed[36] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.store(41, &[v_53, v_54, v_56, v_51])?; seed[37] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.store(42, &[v_50, v_32, v_57, v_51])?; seed[38] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.store(43, &[v_53, v_9, v_10, v_51])?; seed[39] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(3)]; let [v_61]: [G; 1] = context.store(45, &[v_60, v_59, v_22, v_51])?; seed[40] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = context.store(46, &[v_60, v_61, v_58, v_51])?; seed[41] = v_62.as_canonical_u64(); let [v_63]: [G; 1] = context.store(47, &[v_60, v_62, v_43, v_51])?; seed[42] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = context.store(48, &[v_60, v_63, v_52, v_51])?; seed[43] = v_64.as_canonical_u64(); let [v_65]: [G; 1] = context.store(49, &[v_60, v_64, v_30, v_51])?; seed[44] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(5)]; let [v_67]: [G; 1] = context.call::<1>(51, 798, &[v_3, v_66])?; seed[45] = v_67.as_canonical_u64(); let [v_68]: [G; 1] = context.call::<1>(52, 263, &[v_65, v_67])?; seed[46] = v_68.as_canonical_u64(); Ok(()) }, _ => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [v_70]: [G; 1] = context.store(54, &[v_69, v_69, v_69, v_69])?; seed[33] = v_70.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_71]: [G; 1] = [G::from_u64(0)]; let [v_72]: [G; 1] = context.store(56, &[v_71, v_71, v_71, v_71])?; seed[27] = v_72.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_73]: [G; 1] = [G::from_u64(0)]; let [v_74]: [G; 1] = context.store(58, &[v_73, v_73, v_73, v_73])?; seed[23] = v_74.as_canonical_u64(); Ok(()) }, } }, } }, } }, _ => { let [v_75]: [G; 1] = [G::from_u64(0)]; let [v_76]: [G; 1] = context.store(60, &[v_75, v_75, v_75, v_75])?; seed[11] = v_76.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_77]: [G; 1] = [G::from_u64(0)]; let [v_78]: [G; 1] = context.store(62, &[v_77, v_77, v_77, v_77])?; seed[7] = v_78.as_canonical_u64(); Ok(()) }, } }, } } + +fn pack_393_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4]: [G; 1] = context.call::<1>(0, 387, &[])?; seed.u32(140, v_4); let [v_5]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_4])?; seed.u8(236, v_5); match v_5.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6, v_6])?; seed.u32(144, v_7); Ok(()) }, _ => { match v_1.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11]: [G; 4] = context.load::<4>(4, v_2)?; seed.u32(144, v_8); seed.u32(148, v_9); seed.full(16, v_10); seed.full(24, v_11); match v_8.as_canonical_u64() { 2u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 388, &[])?; seed.u32(152, v_12); let [v_13]: [G; 1] = context.call::<1>(6, 2, &[v_9, v_12])?; seed.u8(237, v_13); match v_13.as_canonical_u64() { 0u64 => { let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(8, &[v_14, v_14, v_14, v_14])?; seed.u32(156, v_15); Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(9, 787, &[v_3])?; seed.u32(156, v_16); let [v_17]: [G; 1] = [G::from_u64(5)]; let op_11 = u32_less_than(v_16, v_17); let [v_18]: [G; 1] = [op_11.0]; match v_18.as_canonical_u64() { 1u64 => { let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(13, &[v_19, v_19, v_19, v_19])?; seed.full(32, v_20); Ok(()) }, _ => { let [v_21]: [G; 1] = [G::from_u64(0)]; let [v_22]: [G; 1] = context.call::<1>(15, 789, &[v_3, v_21])?; seed.full(32, v_22); let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.call::<1>(17, 789, &[v_3, v_23])?; seed.u32(160, v_24); let [v_25]: [G; 1] = [G::from_u64(2)]; let [v_26]: [G; 1] = context.call::<1>(19, 789, &[v_3, v_25])?; seed.u32(164, v_26); let [v_27]: [G; 1] = [G::from_u64(3)]; let [v_28]: [G; 1] = context.call::<1>(21, 789, &[v_3, v_27])?; seed.u32(168, v_28); let [v_29]: [G; 1] = [G::from_u64(4)]; let [v_30]: [G; 1] = context.call::<1>(23, 789, &[v_3, v_29])?; seed.full(40, v_30); let [v_31, v_32, v_33, v_34]: [G; 4] = context.load::<4>(24, v_24)?; seed.u8(238, v_31); seed.full(48, v_32); seed.full(56, v_33); seed.full(64, v_34); match v_31.as_canonical_u64() { 4u64 => { let [v_35, v_36, v_37, v_38]: [G; 4] = context.load::<4>(25, v_26)?; seed.u32(172, v_35); seed.full(72, v_36); seed.full(80, v_37); seed.full(88, v_38); match v_35.as_canonical_u64() { 4u64 => { let [v_39]: [G; 1] = [G::from_u64(8)]; let [v_40]: [G; 1] = context.store(27, &[v_39, v_0, v_1, v_37])?; seed.u32(176, v_40); let [v_41]: [G; 1] = [G::from_u64(4)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(30, &[v_41, v_36, v_40, v_42])?; seed.u32(180, v_43); let [v_44, v_45, v_46, v_47]: [G; 4] = context.load::<4>(31, v_28)?; seed.u8(239, v_44); seed.full(96, v_45); seed.full(104, v_46); seed.full(112, v_47); match v_44.as_canonical_u64() { 4u64 => { let [v_48]: [G; 1] = [G::from_u64(8)]; let [v_49]: [G; 1] = context.store(33, &[v_48, v_0, v_1, v_46])?; seed.u32(184, v_49); let [v_50]: [G; 1] = [G::from_u64(4)]; let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.store(36, &[v_50, v_45, v_49, v_51])?; seed.u32(188, v_52); let [v_53]: [G; 1] = [G::from_u64(2)]; let [v_54]: [G; 1] = context.call::<1>(38, 389, &[])?; seed.u32(192, v_54); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.store(40, &[v_55, v_55, v_55])?; seed.u32(196, v_56); let [v_57]: [G; 1] = context.store(41, &[v_53, v_54, v_56, v_51])?; seed.u32(200, v_57); let [v_58]: [G; 1] = context.store(42, &[v_50, v_32, v_57, v_51])?; seed.u32(204, v_58); let [v_59]: [G; 1] = context.store(43, &[v_53, v_9, v_10, v_51])?; seed.u32(208, v_59); let [v_60]: [G; 1] = [G::from_u64(3)]; let [v_61]: [G; 1] = context.store(45, &[v_60, v_59, v_22, v_51])?; seed.u32(212, v_61); let [v_62]: [G; 1] = context.store(46, &[v_60, v_61, v_58, v_51])?; seed.u32(216, v_62); let [v_63]: [G; 1] = context.store(47, &[v_60, v_62, v_43, v_51])?; seed.u32(220, v_63); let [v_64]: [G; 1] = context.store(48, &[v_60, v_63, v_52, v_51])?; seed.u32(224, v_64); let [v_65]: [G; 1] = context.store(49, &[v_60, v_64, v_30, v_51])?; seed.u32(228, v_65); let [v_66]: [G; 1] = [G::from_u64(5)]; let [v_67]: [G; 1] = context.call::<1>(51, 798, &[v_3, v_66])?; seed.u32(232, v_67); let [v_68]: [G; 1] = context.call::<1>(52, 263, &[v_65, v_67])?; seed.full(120, v_68); Ok(()) }, _ => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [v_70]: [G; 1] = context.store(54, &[v_69, v_69, v_69, v_69])?; seed.u32(184, v_70); Ok(()) }, } }, _ => { let [v_71]: [G; 1] = [G::from_u64(0)]; let [v_72]: [G; 1] = context.store(56, &[v_71, v_71, v_71, v_71])?; seed.u32(176, v_72); Ok(()) }, } }, _ => { let [v_73]: [G; 1] = [G::from_u64(0)]; let [v_74]: [G; 1] = context.store(58, &[v_73, v_73, v_73, v_73])?; seed.u32(172, v_74); Ok(()) }, } }, } }, } }, _ => { let [v_75]: [G; 1] = [G::from_u64(0)]; let [v_76]: [G; 1] = context.store(60, &[v_75, v_75, v_75, v_75])?; seed.u32(152, v_76); Ok(()) }, } }, _ => { let [v_77]: [G; 1] = [G::from_u64(0)]; let [v_78]: [G; 1] = context.store(62, &[v_77, v_77, v_77, v_77])?; seed.u32(144, v_78); Ok(()) }, } }, } } + +fn pack_393_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4]: [G; 1] = context.call::<1>(0, 387, &[])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_4])?; seed[6] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6, v_6])?; seed[7] = v_7.as_canonical_u64(); Ok(()) }, _ => { match v_1.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11]: [G; 4] = context.load::<4>(4, v_2)?; seed[7] = v_8.as_canonical_u64(); seed[8] = v_9.as_canonical_u64(); seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); match v_8.as_canonical_u64() { 2u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 388, &[])?; seed[11] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = context.call::<1>(6, 2, &[v_9, v_12])?; seed[12] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(8, &[v_14, v_14, v_14, v_14])?; seed[13] = v_15.as_canonical_u64(); Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(9, 787, &[v_3])?; seed[13] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(5)]; let op_11 = u32_less_than(v_16, v_17); let [v_18]: [G; 1] = [op_11.0]; match v_18.as_canonical_u64() { 1u64 => { let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(13, &[v_19, v_19, v_19, v_19])?; seed[14] = v_20.as_canonical_u64(); Ok(()) }, _ => { let [v_21]: [G; 1] = [G::from_u64(0)]; let [v_22]: [G; 1] = context.call::<1>(15, 789, &[v_3, v_21])?; seed[14] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.call::<1>(17, 789, &[v_3, v_23])?; seed[15] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(2)]; let [v_26]: [G; 1] = context.call::<1>(19, 789, &[v_3, v_25])?; seed[16] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(3)]; let [v_28]: [G; 1] = context.call::<1>(21, 789, &[v_3, v_27])?; seed[17] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(4)]; let [v_30]: [G; 1] = context.call::<1>(23, 789, &[v_3, v_29])?; seed[18] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34]: [G; 4] = context.load::<4>(24, v_24)?; seed[19] = v_31.as_canonical_u64(); seed[20] = v_32.as_canonical_u64(); seed[21] = v_33.as_canonical_u64(); seed[22] = v_34.as_canonical_u64(); match v_31.as_canonical_u64() { 4u64 => { let [v_35, v_36, v_37, v_38]: [G; 4] = context.load::<4>(25, v_26)?; seed[23] = v_35.as_canonical_u64(); seed[24] = v_36.as_canonical_u64(); seed[25] = v_37.as_canonical_u64(); seed[26] = v_38.as_canonical_u64(); match v_35.as_canonical_u64() { 4u64 => { let [v_39]: [G; 1] = [G::from_u64(8)]; let [v_40]: [G; 1] = context.store(27, &[v_39, v_0, v_1, v_37])?; seed[27] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(4)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(30, &[v_41, v_36, v_40, v_42])?; seed[28] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47]: [G; 4] = context.load::<4>(31, v_28)?; seed[29] = v_44.as_canonical_u64(); seed[30] = v_45.as_canonical_u64(); seed[31] = v_46.as_canonical_u64(); seed[32] = v_47.as_canonical_u64(); match v_44.as_canonical_u64() { 4u64 => { let [v_48]: [G; 1] = [G::from_u64(8)]; let [v_49]: [G; 1] = context.store(33, &[v_48, v_0, v_1, v_46])?; seed[33] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = [G::from_u64(4)]; let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.store(36, &[v_50, v_45, v_49, v_51])?; seed[34] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(2)]; let [v_54]: [G; 1] = context.call::<1>(38, 389, &[])?; seed[35] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.store(40, &[v_55, v_55, v_55])?; seed[36] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.store(41, &[v_53, v_54, v_56, v_51])?; seed[37] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.store(42, &[v_50, v_32, v_57, v_51])?; seed[38] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.store(43, &[v_53, v_9, v_10, v_51])?; seed[39] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(3)]; let [v_61]: [G; 1] = context.store(45, &[v_60, v_59, v_22, v_51])?; seed[40] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = context.store(46, &[v_60, v_61, v_58, v_51])?; seed[41] = v_62.as_canonical_u64(); let [v_63]: [G; 1] = context.store(47, &[v_60, v_62, v_43, v_51])?; seed[42] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = context.store(48, &[v_60, v_63, v_52, v_51])?; seed[43] = v_64.as_canonical_u64(); let [v_65]: [G; 1] = context.store(49, &[v_60, v_64, v_30, v_51])?; seed[44] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(5)]; let [v_67]: [G; 1] = context.call::<1>(51, 798, &[v_3, v_66])?; seed[45] = v_67.as_canonical_u64(); let [v_68]: [G; 1] = context.call::<1>(52, 263, &[v_65, v_67])?; seed[46] = v_68.as_canonical_u64(); Ok(()) }, _ => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [v_70]: [G; 1] = context.store(54, &[v_69, v_69, v_69, v_69])?; seed[33] = v_70.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_71]: [G; 1] = [G::from_u64(0)]; let [v_72]: [G; 1] = context.store(56, &[v_71, v_71, v_71, v_71])?; seed[27] = v_72.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_73]: [G; 1] = [G::from_u64(0)]; let [v_74]: [G; 1] = context.store(58, &[v_73, v_73, v_73, v_73])?; seed[23] = v_74.as_canonical_u64(); Ok(()) }, } }, } }, } }, _ => { let [v_75]: [G; 1] = [G::from_u64(0)]; let [v_76]: [G; 1] = context.store(60, &[v_75, v_75, v_75, v_75])?; seed[11] = v_76.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_77]: [G; 1] = [G::from_u64(0)]; let [v_78]: [G; 1] = context.store(62, &[v_77, v_77, v_77, v_77])?; seed[7] = v_78.as_canonical_u64(); Ok(()) }, } }, } } + +fn write_393(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 3] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_5 - G::from_u64(0)).inverse().as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11]: [G; 4] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 4] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_11.as_canonical_u64(); match v_8.as_canonical_u64() { 2u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 9] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_15.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 10] = (v_13 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(5)]; let op_11 = u32_less_than(v_16, v_17); let [v_18]: [G; 1] = [op_11.0]; row[offsets.auxiliaries + 12] = op_11.1[0].as_canonical_u64(); row[offsets.auxiliaries + 13] = op_11.1[1].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_11.1[2].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_11.1[3].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_11.1[4].as_canonical_u64(); row[offsets.auxiliaries + 17] = op_11.1[5].as_canonical_u64(); match v_18.as_canonical_u64() { 1u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 18] = (v_18 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 20] = v_24.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 22] = v_28.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 23] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34]: [G; 4] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 24] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_34.as_canonical_u64(); match v_31.as_canonical_u64() { 4u64 => { let [v_35, v_36, v_37, v_38]: [G; 4] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26])]; row[offsets.auxiliaries + 28] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_38.as_canonical_u64(); match v_35.as_canonical_u64() { 4u64 => { let [v_40]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 32] = v_40.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 33] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47]: [G; 4] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 34] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_47.as_canonical_u64(); match v_44.as_canonical_u64() { 4u64 => { let [v_49]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 38] = v_49.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[34])]; row[offsets.auxiliaries + 39] = v_52.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[35])]; row[offsets.auxiliaries + 40] = v_54.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 41] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[37])]; row[offsets.auxiliaries + 42] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[38])]; row[offsets.auxiliaries + 43] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 44] = v_59.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_u64(seed[40])]; row[offsets.auxiliaries + 45] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = [G::from_u64(seed[41])]; row[offsets.auxiliaries + 46] = v_62.as_canonical_u64(); let [v_63]: [G; 1] = [G::from_u64(seed[42])]; row[offsets.auxiliaries + 47] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = [G::from_u64(seed[43])]; row[offsets.auxiliaries + 48] = v_64.as_canonical_u64(); let [v_65]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 49] = v_65.as_canonical_u64(); let [v_67]: [G; 1] = [G::from_u64(seed[45])]; row[offsets.auxiliaries + 50] = v_67.as_canonical_u64(); let [v_68]: [G; 1] = [G::from_u64(seed[46])]; row[offsets.auxiliaries + 51] = v_68.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 38] = (v_44 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_70]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 39] = v_70.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 32] = (v_35 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_72]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 33] = v_72.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 28] = (v_31 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_74]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 29] = v_74.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, } }, } }, _ => { row[offsets.auxiliaries + 8] = (v_8 - G::from_u64(2)).inverse().as_canonical_u64(); let [v_76]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 9] = v_76.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 4] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_78]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_78.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, } } + +static SCHEMA_393: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 128, 8, 132, 136, 140, 236, 144, 148, 16, 24, 152, 237, 156, 32, 160, 164, 168, 40, 238, 48, 56, 64, 172, 72, 80, 88, 176, 180, 239, 96, 104, 112, 184, 188, 192, 196, 200, 204, 208, 212, 216, 220, 224, 228, 232, 120], bytes: 240 }; + +fn pack_398(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 156, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); let [v_50]: [G; 1] = 'yield_0: { match v_2.as_canonical_u64() { 1u64 => { let [v_3]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_3]; }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 157, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 170, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_9]; }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 171, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_12]; }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 172, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_15]; }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 176, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_18]; }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 175, &[])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed[15] = v_20.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_21]; }, _ => { let [v_22]: [G; 1] = context.call::<1>(21, 173, &[])?; seed[16] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(22, 2, &[v_0, v_22])?; seed[17] = v_23.as_canonical_u64(); match v_23.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_24]; }, _ => { let [v_25]: [G; 1] = context.call::<1>(24, 174, &[])?; seed[18] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.call::<1>(25, 2, &[v_0, v_25])?; seed[19] = v_26.as_canonical_u64(); match v_26.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_27]; }, _ => { let [v_28]: [G; 1] = context.call::<1>(27, 182, &[])?; seed[20] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = context.call::<1>(28, 2, &[v_0, v_28])?; seed[21] = v_29.as_canonical_u64(); match v_29.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_30]; }, _ => { let [v_31]: [G; 1] = context.call::<1>(30, 183, &[])?; seed[22] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.call::<1>(31, 2, &[v_0, v_31])?; seed[23] = v_32.as_canonical_u64(); match v_32.as_canonical_u64() { 1u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_33]; }, _ => { let [v_34]: [G; 1] = context.call::<1>(33, 177, &[])?; seed[24] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.call::<1>(34, 2, &[v_0, v_34])?; seed[25] = v_35.as_canonical_u64(); match v_35.as_canonical_u64() { 1u64 => { let [v_36]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_36]; }, _ => { let [v_37]: [G; 1] = context.call::<1>(36, 178, &[])?; seed[26] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = context.call::<1>(37, 2, &[v_0, v_37])?; seed[27] = v_38.as_canonical_u64(); match v_38.as_canonical_u64() { 1u64 => { let [v_39]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_39]; }, _ => { let [v_40]: [G; 1] = context.call::<1>(39, 179, &[])?; seed[28] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = context.call::<1>(40, 2, &[v_0, v_40])?; seed[29] = v_41.as_canonical_u64(); match v_41.as_canonical_u64() { 1u64 => { let [v_42]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_42]; }, _ => { let [v_43]: [G; 1] = context.call::<1>(42, 180, &[])?; seed[30] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(43, 2, &[v_0, v_43])?; seed[31] = v_44.as_canonical_u64(); match v_44.as_canonical_u64() { 1u64 => { let [v_45]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_45]; }, _ => { let [v_46]: [G; 1] = context.call::<1>(45, 181, &[])?; seed[32] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = context.call::<1>(46, 2, &[v_0, v_46])?; seed[33] = v_47.as_canonical_u64(); match v_47.as_canonical_u64() { 1u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_48]; }, _ => { let [v_49]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_49]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; match v_50.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_52]: [G; 1] = context.call::<1>(50, 227, &[v_0])?; seed[34] = v_52.as_canonical_u64(); match v_52.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_54]: [G; 1] = context.call::<1>(52, 205, &[v_0])?; seed[35] = v_54.as_canonical_u64(); match v_54.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_56]: [G; 1] = context.call::<1>(54, 192, &[v_0])?; seed[36] = v_56.as_canonical_u64(); match v_56.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_58]: [G; 1] = context.call::<1>(56, 533, &[v_0])?; seed[37] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_60]: [G; 1] = context.call::<1>(58, 250, &[v_0])?; seed[38] = v_60.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } } + +fn pack_398_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 156, &[])?; seed.u32(12, v_1); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed.u8(78, v_2); let [v_50]: [G; 1] = 'yield_0: { match v_2.as_canonical_u64() { 1u64 => { let [v_3]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_3]; }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 157, &[])?; seed.u32(16, v_4); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed.u8(79, v_5); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 170, &[])?; seed.u32(20, v_7); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed.u8(80, v_8); match v_8.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_9]; }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 171, &[])?; seed.u32(24, v_10); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed.u8(81, v_11); match v_11.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_12]; }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 172, &[])?; seed.u32(28, v_13); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed.u8(82, v_14); match v_14.as_canonical_u64() { 1u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_15]; }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 176, &[])?; seed.u32(32, v_16); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed.u8(83, v_17); match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_18]; }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 175, &[])?; seed.u32(36, v_19); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed.u8(84, v_20); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_21]; }, _ => { let [v_22]: [G; 1] = context.call::<1>(21, 173, &[])?; seed.u32(40, v_22); let [v_23]: [G; 1] = context.call::<1>(22, 2, &[v_0, v_22])?; seed.u8(85, v_23); match v_23.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_24]; }, _ => { let [v_25]: [G; 1] = context.call::<1>(24, 174, &[])?; seed.u32(44, v_25); let [v_26]: [G; 1] = context.call::<1>(25, 2, &[v_0, v_25])?; seed.u8(86, v_26); match v_26.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_27]; }, _ => { let [v_28]: [G; 1] = context.call::<1>(27, 182, &[])?; seed.u32(48, v_28); let [v_29]: [G; 1] = context.call::<1>(28, 2, &[v_0, v_28])?; seed.u8(87, v_29); match v_29.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_30]; }, _ => { let [v_31]: [G; 1] = context.call::<1>(30, 183, &[])?; seed.u32(52, v_31); let [v_32]: [G; 1] = context.call::<1>(31, 2, &[v_0, v_31])?; seed.u8(88, v_32); match v_32.as_canonical_u64() { 1u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_33]; }, _ => { let [v_34]: [G; 1] = context.call::<1>(33, 177, &[])?; seed.u32(56, v_34); let [v_35]: [G; 1] = context.call::<1>(34, 2, &[v_0, v_34])?; seed.u8(89, v_35); match v_35.as_canonical_u64() { 1u64 => { let [v_36]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_36]; }, _ => { let [v_37]: [G; 1] = context.call::<1>(36, 178, &[])?; seed.u32(60, v_37); let [v_38]: [G; 1] = context.call::<1>(37, 2, &[v_0, v_37])?; seed.u8(90, v_38); match v_38.as_canonical_u64() { 1u64 => { let [v_39]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_39]; }, _ => { let [v_40]: [G; 1] = context.call::<1>(39, 179, &[])?; seed.u32(64, v_40); let [v_41]: [G; 1] = context.call::<1>(40, 2, &[v_0, v_40])?; seed.u8(91, v_41); match v_41.as_canonical_u64() { 1u64 => { let [v_42]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_42]; }, _ => { let [v_43]: [G; 1] = context.call::<1>(42, 180, &[])?; seed.u32(68, v_43); let [v_44]: [G; 1] = context.call::<1>(43, 2, &[v_0, v_43])?; seed.u8(92, v_44); match v_44.as_canonical_u64() { 1u64 => { let [v_45]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_45]; }, _ => { let [v_46]: [G; 1] = context.call::<1>(45, 181, &[])?; seed.u32(72, v_46); let [v_47]: [G; 1] = context.call::<1>(46, 2, &[v_0, v_46])?; seed.u8(93, v_47); match v_47.as_canonical_u64() { 1u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_48]; }, _ => { let [v_49]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_49]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; match v_50.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_52]: [G; 1] = context.call::<1>(50, 227, &[v_0])?; seed.u8(94, v_52); match v_52.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_54]: [G; 1] = context.call::<1>(52, 205, &[v_0])?; seed.u8(95, v_54); match v_54.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_56]: [G; 1] = context.call::<1>(54, 192, &[v_0])?; seed.u8(96, v_56); match v_56.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_58]: [G; 1] = context.call::<1>(56, 533, &[v_0])?; seed.u8(97, v_58); match v_58.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_60]: [G; 1] = context.call::<1>(58, 250, &[v_0])?; seed.u16(76, v_60); Ok(()) }, } }, } }, } }, } }, } } + +fn pack_398_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 156, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); let [v_50]: [G; 1] = 'yield_0: { match v_2.as_canonical_u64() { 1u64 => { let [v_3]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_3]; }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 157, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 170, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_9]; }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 171, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_12]; }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 172, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_15]; }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 176, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_18]; }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 175, &[])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed[15] = v_20.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_21]; }, _ => { let [v_22]: [G; 1] = context.call::<1>(21, 173, &[])?; seed[16] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(22, 2, &[v_0, v_22])?; seed[17] = v_23.as_canonical_u64(); match v_23.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_24]; }, _ => { let [v_25]: [G; 1] = context.call::<1>(24, 174, &[])?; seed[18] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.call::<1>(25, 2, &[v_0, v_25])?; seed[19] = v_26.as_canonical_u64(); match v_26.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_27]; }, _ => { let [v_28]: [G; 1] = context.call::<1>(27, 182, &[])?; seed[20] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = context.call::<1>(28, 2, &[v_0, v_28])?; seed[21] = v_29.as_canonical_u64(); match v_29.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_30]; }, _ => { let [v_31]: [G; 1] = context.call::<1>(30, 183, &[])?; seed[22] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.call::<1>(31, 2, &[v_0, v_31])?; seed[23] = v_32.as_canonical_u64(); match v_32.as_canonical_u64() { 1u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_33]; }, _ => { let [v_34]: [G; 1] = context.call::<1>(33, 177, &[])?; seed[24] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.call::<1>(34, 2, &[v_0, v_34])?; seed[25] = v_35.as_canonical_u64(); match v_35.as_canonical_u64() { 1u64 => { let [v_36]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_36]; }, _ => { let [v_37]: [G; 1] = context.call::<1>(36, 178, &[])?; seed[26] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = context.call::<1>(37, 2, &[v_0, v_37])?; seed[27] = v_38.as_canonical_u64(); match v_38.as_canonical_u64() { 1u64 => { let [v_39]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_39]; }, _ => { let [v_40]: [G; 1] = context.call::<1>(39, 179, &[])?; seed[28] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = context.call::<1>(40, 2, &[v_0, v_40])?; seed[29] = v_41.as_canonical_u64(); match v_41.as_canonical_u64() { 1u64 => { let [v_42]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_42]; }, _ => { let [v_43]: [G; 1] = context.call::<1>(42, 180, &[])?; seed[30] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(43, 2, &[v_0, v_43])?; seed[31] = v_44.as_canonical_u64(); match v_44.as_canonical_u64() { 1u64 => { let [v_45]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_45]; }, _ => { let [v_46]: [G; 1] = context.call::<1>(45, 181, &[])?; seed[32] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = context.call::<1>(46, 2, &[v_0, v_46])?; seed[33] = v_47.as_canonical_u64(); match v_47.as_canonical_u64() { 1u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_48]; }, _ => { let [v_49]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_49]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; match v_50.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_52]: [G; 1] = context.call::<1>(50, 227, &[v_0])?; seed[34] = v_52.as_canonical_u64(); match v_52.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_54]: [G; 1] = context.call::<1>(52, 205, &[v_0])?; seed[35] = v_54.as_canonical_u64(); match v_54.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_56]: [G; 1] = context.call::<1>(54, 192, &[v_0])?; seed[36] = v_56.as_canonical_u64(); match v_56.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_58]: [G; 1] = context.call::<1>(56, 533, &[v_0])?; seed[37] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_60]: [G; 1] = context.call::<1>(58, 250, &[v_0])?; seed[38] = v_60.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } } + +fn write_398(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_50]: [G; 1] = 'yield_0: { match v_2.as_canonical_u64() { 1u64 => { let [v_3]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { row[offsets.auxiliaries + 3] = (v_2 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_6]; }, _ => { row[offsets.auxiliaries + 6] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_9]; }, _ => { row[offsets.auxiliaries + 9] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_12]; }, _ => { row[offsets.auxiliaries + 12] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 [v_15]; }, _ => { row[offsets.auxiliaries + 15] = (v_14 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 [v_18]; }, _ => { row[offsets.auxiliaries + 18] = (v_17 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); break 'yield_0 [v_21]; }, _ => { row[offsets.auxiliaries + 21] = (v_20 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); match v_23.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); break 'yield_0 [v_24]; }, _ => { row[offsets.auxiliaries + 24] = (v_23 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); match v_26.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); break 'yield_0 [v_27]; }, _ => { row[offsets.auxiliaries + 27] = (v_26 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); match v_29.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); break 'yield_0 [v_30]; }, _ => { row[offsets.auxiliaries + 30] = (v_29 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); match v_32.as_canonical_u64() { 1u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); break 'yield_0 [v_33]; }, _ => { row[offsets.auxiliaries + 33] = (v_32 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[25])]; row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); match v_35.as_canonical_u64() { 1u64 => { let [v_36]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); break 'yield_0 [v_36]; }, _ => { row[offsets.auxiliaries + 36] = (v_35 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_37]: [G; 1] = [G::from_u64(seed[26])]; row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); match v_38.as_canonical_u64() { 1u64 => { let [v_39]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); break 'yield_0 [v_39]; }, _ => { row[offsets.auxiliaries + 39] = (v_38 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); match v_41.as_canonical_u64() { 1u64 => { let [v_42]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 13] = G::ONE.as_canonical_u64(); break 'yield_0 [v_42]; }, _ => { row[offsets.auxiliaries + 42] = (v_41 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); match v_44.as_canonical_u64() { 1u64 => { let [v_45]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 14] = G::ONE.as_canonical_u64(); break 'yield_0 [v_45]; }, _ => { row[offsets.auxiliaries + 45] = (v_44 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_46]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); match v_47.as_canonical_u64() { 1u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 15] = G::ONE.as_canonical_u64(); break 'yield_0 [v_48]; }, _ => { row[offsets.auxiliaries + 48] = (v_47 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_49]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 16] = G::ONE.as_canonical_u64(); break 'yield_0 [v_49]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); match v_50.as_canonical_u64() { 1u64 => { row[offsets.selectors + 17] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 50] = (v_50 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[34])]; row[offsets.auxiliaries + 51] = v_52.as_canonical_u64(); match v_52.as_canonical_u64() { 1u64 => { row[offsets.selectors + 18] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 52] = (v_52 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[35])]; row[offsets.auxiliaries + 53] = v_54.as_canonical_u64(); match v_54.as_canonical_u64() { 1u64 => { row[offsets.selectors + 19] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 54] = (v_54 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 55] = v_56.as_canonical_u64(); match v_56.as_canonical_u64() { 1u64 => { row[offsets.selectors + 20] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 56] = (v_56 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[37])]; row[offsets.auxiliaries + 57] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 1u64 => { row[offsets.selectors + 21] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 58] = (v_58 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[38])]; row[offsets.auxiliaries + 59] = v_60.as_canonical_u64(); match v_60.as_canonical_u64() { 1u64 => { row[offsets.selectors + 22] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 60] = (v_60 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 23] = G::ONE.as_canonical_u64(); }, } }, } }, } }, } }, } }, } } + +static SCHEMA_398: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U16], offsets: &[0, 8, 12, 78, 16, 79, 20, 80, 24, 81, 28, 82, 32, 83, 36, 84, 40, 85, 44, 86, 48, 87, 52, 88, 56, 89, 60, 90, 64, 91, 68, 92, 72, 93, 94, 95, 96, 97, 76], bytes: 104 }; + +fn pack_448(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let op_0 = u32_less_than(v_0, v_1); let [v_3]: [G; 1] = [op_0.0]; match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = context.returned::<1>(1)?; seed[4] = v_4.as_canonical_u64(); Ok(()) }, _ => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed[4] = v_5.as_canonical_u64(); Ok(()) }, } } + +fn pack_448_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let op_0 = u32_less_than(v_0, v_1); let [v_3]: [G; 1] = [op_0.0]; match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = context.returned::<1>(1)?; seed.u8(20, v_4); Ok(()) }, _ => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed.u8(20, v_5); Ok(()) }, } } + +fn pack_448_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let op_0 = u32_less_than(v_0, v_1); let [v_3]: [G; 1] = [op_0.0]; match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = context.check_returned::<1>(1, 449, &[v_0, v_1, v_2])?; seed[4] = v_4.as_canonical_u64(); Ok(()) }, _ => { let [v_5]: [G; 1] = context.check_returned::<1>(2, 449, &[v_1, v_0, v_2])?; seed[4] = v_5.as_canonical_u64(); Ok(()) }, } } + +fn write_448(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let op_0 = u32_less_than(v_0, v_1); let [v_3]: [G; 1] = [op_0.0]; row[offsets.auxiliaries + 1] = op_0.1[0].as_canonical_u64(); row[offsets.auxiliaries + 2] = op_0.1[1].as_canonical_u64(); row[offsets.auxiliaries + 3] = op_0.1[2].as_canonical_u64(); row[offsets.auxiliaries + 4] = op_0.1[3].as_canonical_u64(); row[offsets.auxiliaries + 5] = op_0.1[4].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_0.1[5].as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 7] = v_4.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 7] = (v_3 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 8] = v_5.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_448: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 16, 20], bytes: 24 }; + +fn pack_454(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 452, &[v_0])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.call::<1>(1, 452, &[v_1])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [v_3 * v_4]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7, v_8, v_9]: [G; 3] = context.call::<3>(4, 453, &[v_0])?; seed[6] = v_7.as_canonical_u64(); seed[7] = v_8.as_canonical_u64(); seed[8] = v_9.as_canonical_u64(); let [v_10, v_11, v_12]: [G; 3] = context.call::<3>(5, 453, &[v_1])?; seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); seed[11] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [v_7 * v_10]; match v_13.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_15]: [G; 1] = context.call::<1>(8, 346, &[v_9, v_12])?; seed[12] = v_15.as_canonical_u64(); match v_15.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_18]: [G; 1] = context.call::<1>(11, 446, &[v_8, v_11, v_2])?; seed[13] = v_18.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn pack_454_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 452, &[v_0])?; seed.u8(36, v_3); let [v_4]: [G; 1] = context.call::<1>(1, 452, &[v_1])?; seed.u8(37, v_4); let [v_5]: [G; 1] = [v_3 * v_4]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7, v_8, v_9]: [G; 3] = context.call::<3>(4, 453, &[v_0])?; seed.u8(38, v_7); seed.u32(20, v_8); seed.u32(24, v_9); let [v_10, v_11, v_12]: [G; 3] = context.call::<3>(5, 453, &[v_1])?; seed.u8(39, v_10); seed.u32(28, v_11); seed.u32(32, v_12); let [v_13]: [G; 1] = [v_7 * v_10]; match v_13.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_15]: [G; 1] = context.call::<1>(8, 346, &[v_9, v_12])?; seed.u8(40, v_15); match v_15.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_18]: [G; 1] = context.call::<1>(11, 446, &[v_8, v_11, v_2])?; seed.u8(41, v_18); Ok(()) }, } }, } }, } } + +fn pack_454_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 452, &[v_0])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.call::<1>(1, 452, &[v_1])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [v_3 * v_4]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7, v_8, v_9]: [G; 3] = context.call::<3>(4, 453, &[v_0])?; seed[6] = v_7.as_canonical_u64(); seed[7] = v_8.as_canonical_u64(); seed[8] = v_9.as_canonical_u64(); let [v_10, v_11, v_12]: [G; 3] = context.call::<3>(5, 453, &[v_1])?; seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); seed[11] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [v_7 * v_10]; match v_13.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_15]: [G; 1] = context.call::<1>(8, 346, &[v_9, v_12])?; seed[12] = v_15.as_canonical_u64(); match v_15.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_18]: [G; 1] = context.call::<1>(11, 446, &[v_8, v_11, v_2])?; seed[13] = v_18.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn write_454(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [v_3 * v_4]; row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 4] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_9.as_canonical_u64(); let [v_10, v_11, v_12]: [G; 3] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [v_7 * v_10]; row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_13 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); match v_15.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 14] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, } }, } } + +static SCHEMA_454: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 16, 36, 37, 38, 20, 24, 39, 28, 32, 40, 41], bytes: 48 }; + +fn pack_484(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5]: [G; 2] = context.call::<2>(0, 491, &[v_1])?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 431, &[v_5, v_3])?; seed[7] = v_6.as_canonical_u64(); let [v_9, v_10, v_11]: [G; 3] = context.returned::<3>(4)?; seed[8] = v_9.as_canonical_u64(); seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_484_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5]: [G; 2] = context.call::<2>(0, 491, &[v_1])?; seed.u8(52, v_4); seed.u32(44, v_5); match v_4.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 431, &[v_5, v_3])?; seed.u32(48, v_6); let [v_9, v_10, v_11]: [G; 3] = context.returned::<3>(4)?; seed.u8(53, v_9); seed.full(16, v_10); seed.full(24, v_11); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_484_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5]: [G; 2] = context.call::<2>(0, 491, &[v_1])?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 431, &[v_5, v_3])?; seed[7] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(1)]; let [v_8]: [G; 1] = [v_2 - v_7]; let [v_9, v_10, v_11]: [G; 3] = context.check_returned::<3>(4, 480, &[v_0, v_6, v_8, v_3])?; seed[8] = v_9.as_canonical_u64(); seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn write_484(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); let [v_9, v_10, v_11]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_4 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_484: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 32, 36, 8, 40, 52, 44, 48, 53, 16, 24], bytes: 56 }; + +fn pack_509(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(0, v_1)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 787, &[v_2])?; seed[8] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_9]: [G; 1] = context.returned::<1>(3)?; seed[9] = v_9.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_10, v_11, v_12, v_13]: [G; 4] = context.load::<4>(4, v_0)?; seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); match v_10.as_canonical_u64() { 5u64 => { let [v_14]: [G; 1] = context.call::<1>(5, 787, &[v_2])?; seed[12] = v_14.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_14.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, _ => { let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.call::<1>(7, 379, &[v_11, v_2, v_15])?; seed[13] = v_16.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = context.store(10, &[v_18, v_5, v_2])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.returned::<1>(11)?; seed[15] = v_20.as_canonical_u64(); Ok(()) }, _ => { let [v_21]: [G; 1] = context.call::<1>(12, 787, &[v_2])?; seed[12] = v_21.as_canonical_u64(); let [v_24]: [G; 1] = 'yield_0: { match v_21.as_canonical_u64() { 0u64 => { break 'yield_0 [v_0]; }, _ => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = context.call::<1>(14, 379, &[v_0, v_2, v_22])?; seed[13] = v_23.as_canonical_u64(); break 'yield_0 [v_23]; }, } }; let [v_25]: [G; 1] = context.call::<1>(15, 425, &[v_24, v_3])?; seed[14] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29]: [G; 4] = context.load::<4>(16, v_25)?; seed[15] = v_26.as_canonical_u64(); seed[16] = v_27.as_canonical_u64(); seed[17] = v_28.as_canonical_u64(); seed[18] = v_29.as_canonical_u64(); match v_26.as_canonical_u64() { 5u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(20, &[v_31, v_31, v_31])?; seed[19] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = context.store(21, &[v_30, v_5, v_32])?; seed[20] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = context.returned::<1>(22)?; seed[21] = v_34.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(509, v_26)) }, } }, } }, _ => { Err(no_match(509, v_4)) }, } } + +fn pack_509_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(116, v_4); seed.u32(80, v_5); seed.u32(84, v_6); match v_4.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 787, &[v_2])?; seed.full(8, v_7); match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_9]: [G; 1] = context.returned::<1>(3)?; seed.full(16, v_9); Ok(()) }, } }, 0u64 => { let [v_10, v_11, v_12, v_13]: [G; 4] = context.load::<4>(4, v_0)?; seed.full(8, v_10); seed.full(16, v_11); seed.u32(88, v_12); seed.full(24, v_13); match v_10.as_canonical_u64() { 5u64 => { let [v_14]: [G; 1] = context.call::<1>(5, 787, &[v_2])?; seed.full(32, v_14); let []: [G; 0] = 'yield_0: { match v_14.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, _ => { let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.call::<1>(7, 379, &[v_11, v_2, v_15])?; seed.u32(92, v_16); break 'yield_0 []; }, } }; let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = context.store(10, &[v_18, v_5, v_2])?; seed.u32(96, v_19); let [v_20]: [G; 1] = context.returned::<1>(11)?; seed.full(40, v_20); Ok(()) }, _ => { let [v_21]: [G; 1] = context.call::<1>(12, 787, &[v_2])?; seed.full(32, v_21); let [v_24]: [G; 1] = 'yield_0: { match v_21.as_canonical_u64() { 0u64 => { break 'yield_0 [v_0]; }, _ => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = context.call::<1>(14, 379, &[v_0, v_2, v_22])?; seed.u32(92, v_23); break 'yield_0 [v_23]; }, } }; let [v_25]: [G; 1] = context.call::<1>(15, 425, &[v_24, v_3])?; seed.u32(96, v_25); let [v_26, v_27, v_28, v_29]: [G; 4] = context.load::<4>(16, v_25)?; seed.full(40, v_26); seed.u32(100, v_27); seed.u32(104, v_28); seed.full(48, v_29); match v_26.as_canonical_u64() { 5u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(20, &[v_31, v_31, v_31])?; seed.u32(108, v_32); let [v_33]: [G; 1] = context.store(21, &[v_30, v_5, v_32])?; seed.u32(112, v_33); let [v_34]: [G; 1] = context.returned::<1>(22)?; seed.full(56, v_34); Ok(()) }, _ => { Err(no_match(509, v_26)) }, } }, } }, _ => { Err(no_match(509, v_4)) }, } } + +fn pack_509_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(0, v_1)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 787, &[v_2])?; seed[8] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = context.check_returned::<1>(3, 379, &[v_0, v_2, v_8])?; seed[9] = v_9.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_10, v_11, v_12, v_13]: [G; 4] = context.load::<4>(4, v_0)?; seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); match v_10.as_canonical_u64() { 5u64 => { let [v_14]: [G; 1] = context.call::<1>(5, 787, &[v_2])?; seed[12] = v_14.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_14.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, _ => { let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.call::<1>(7, 379, &[v_11, v_2, v_15])?; seed[13] = v_16.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = context.store(10, &[v_18, v_5, v_2])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.check_returned::<1>(11, 509, &[v_12, v_6, v_19, v_3])?; seed[15] = v_20.as_canonical_u64(); Ok(()) }, _ => { let [v_21]: [G; 1] = context.call::<1>(12, 787, &[v_2])?; seed[12] = v_21.as_canonical_u64(); let [v_24]: [G; 1] = 'yield_0: { match v_21.as_canonical_u64() { 0u64 => { break 'yield_0 [v_0]; }, _ => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = context.call::<1>(14, 379, &[v_0, v_2, v_22])?; seed[13] = v_23.as_canonical_u64(); break 'yield_0 [v_23]; }, } }; let [v_25]: [G; 1] = context.call::<1>(15, 425, &[v_24, v_3])?; seed[14] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29]: [G; 4] = context.load::<4>(16, v_25)?; seed[15] = v_26.as_canonical_u64(); seed[16] = v_27.as_canonical_u64(); seed[17] = v_28.as_canonical_u64(); seed[18] = v_29.as_canonical_u64(); match v_26.as_canonical_u64() { 5u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(20, &[v_31, v_31, v_31])?; seed[19] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = context.store(21, &[v_30, v_5, v_32])?; seed[20] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = context.check_returned::<1>(22, 509, &[v_28, v_6, v_33, v_3])?; seed[21] = v_34.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(509, v_26)) }, } }, } }, _ => { Err(no_match(509, v_4)) }, } } + +fn write_509(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 5] = (v_7 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_10, v_11, v_12, v_13]: [G; 4] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 4] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_13.as_canonical_u64(); match v_10.as_canonical_u64() { 5u64 => { let [v_14]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 8] = v_14.as_canonical_u64(); let [v_17]: [G; 1] = 'yield_0: { match v_14.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_11]; }, _ => { row[offsets.auxiliaries + 9] = (v_14 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_16.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_16]; }, } }; row[offsets.auxiliaries + 11] = v_17.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 13] = v_20.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 8] = (v_10 - G::from_u64(5)).inverse().as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 9] = v_21.as_canonical_u64(); let [v_24]: [G; 1] = 'yield_0: { match v_21.as_canonical_u64() { 0u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 [v_0]; }, _ => { row[offsets.auxiliaries + 10] = (v_21 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_23.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); break 'yield_0 [v_23]; }, } }; row[offsets.auxiliaries + 12] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 13] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29]: [G; 4] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18])]; row[offsets.auxiliaries + 14] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_29.as_canonical_u64(); match v_26.as_canonical_u64() { 5u64 => { let [v_32]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 18] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 19] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 20] = v_34.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(509, v_26)) }, } }, } }, _ => { Err(no_match(509, v_4)) }, } } + +static SCHEMA_509: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 64, 68, 72, 76, 116, 80, 84, 8, 16, 88, 24, 32, 92, 96, 40, 100, 104, 48, 108, 112, 56], bytes: 120 }; + +fn pack_533(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 519, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 520, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 521, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 531, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 530, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 532, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } } + +fn pack_533_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 519, &[])?; seed.u32(12, v_1); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed.u8(36, v_2); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 520, &[])?; seed.u32(16, v_4); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed.u8(37, v_5); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 521, &[])?; seed.u32(20, v_7); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed.u8(38, v_8); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 531, &[])?; seed.u32(24, v_10); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed.u8(39, v_11); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 530, &[])?; seed.u32(28, v_13); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed.u8(40, v_14); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 532, &[])?; seed.u32(32, v_16); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed.u8(41, v_17); Ok(()) }, } }, } }, } }, } }, } } + +fn pack_533_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 519, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 520, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 521, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 531, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 530, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 532, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } } + +fn write_533(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_2 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 6] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 9] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 15] = (v_14 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 18] = (v_17 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, } }, } }, } }, } }, } } + +static SCHEMA_533: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 36, 16, 37, 20, 38, 24, 39, 28, 40, 32, 41], bytes: 48 }; + +fn pack_605(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 5u64 => { let [v_8]: [G; 1] = context.returned::<1>(3)?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(605, v_2)) }, } }, } } + +fn pack_605_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(48, v_2); seed.full(16, v_3); seed.u32(44, v_4); seed.full(24, v_5); match v_2.as_canonical_u64() { 5u64 => { let [v_8]: [G; 1] = context.returned::<1>(3)?; seed.full(32, v_8); Ok(()) }, _ => { Err(no_match(605, v_2)) }, } }, } } + +fn pack_605_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 5u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [v_1 - v_6]; let [v_8]: [G; 1] = context.check_returned::<1>(3, 605, &[v_4, v_7])?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(605, v_2)) }, } }, } } + +fn write_605(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_2, v_3, v_4, v_5]: [G; 4] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 5u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(605, v_2)) }, } }, } } + +static SCHEMA_605: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 40, 8, 48, 16, 44, 24, 32], bytes: 56 }; + +fn pack_716(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let [v_13]: [G; 1] = context.call::<1>(0, 594, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11])?; seed[14] = v_13.as_canonical_u64(); match v_0.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(4, &[v_15, v_15, v_15])?; seed[15] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(5, 517, &[v_2, v_16])?; seed[16] = v_17.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(11, &[v_19, v_19, v_19])?; seed[15] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(12, 517, &[v_2, v_20])?; seed[16] = v_21.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.store(20, &[v_23, v_23, v_23])?; seed[15] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = context.call::<1>(21, 517, &[v_2, v_24])?; seed[16] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.store(22, &[v_22, v_22, v_22])?; seed[17] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = context.call::<1>(23, 332, &[v_25, v_26])?; seed[18] = v_27.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_29]: [G; 1] = [G::from_u64(1)]; let [v_30]: [G; 1] = context.store(32, &[v_29, v_29, v_29])?; seed[15] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(33, 517, &[v_2, v_30])?; seed[16] = v_31.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; let [v_34]: [G; 1] = context.store(40, &[v_33, v_33, v_33])?; seed[15] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.call::<1>(41, 517, &[v_2, v_34])?; seed[16] = v_35.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_37]: [G; 1] = [G::from_u64(1)]; let [v_38]: [G; 1] = context.store(47, &[v_37, v_37, v_37])?; seed[15] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.call::<1>(48, 517, &[v_2, v_38])?; seed[16] = v_39.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_41]: [G; 1] = [G::from_u64(1)]; let [v_42]: [G; 1] = context.store(56, &[v_41, v_41, v_41])?; seed[15] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.call::<1>(57, 517, &[v_2, v_42])?; seed[16] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(59, 297, &[v_3, v_4])?; seed[17] = v_44.as_canonical_u64(); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 12] = context.load::<12>(60, v_44)?; seed[18] = v_45.as_canonical_u64(); seed[19] = v_46.as_canonical_u64(); seed[20] = v_47.as_canonical_u64(); seed[21] = v_48.as_canonical_u64(); seed[22] = v_49.as_canonical_u64(); seed[23] = v_50.as_canonical_u64(); seed[24] = v_51.as_canonical_u64(); seed[25] = v_52.as_canonical_u64(); seed[26] = v_53.as_canonical_u64(); seed[27] = v_54.as_canonical_u64(); seed[28] = v_55.as_canonical_u64(); seed[29] = v_56.as_canonical_u64(); match v_45.as_canonical_u64() { 5u64 => { let [v_57]: [G; 1] = [v_48 + v_49]; let [v_58]: [G; 1] = [G::from_u64(1)]; let [v_59]: [G; 1] = context.store(66, &[v_58, v_58, v_58])?; seed[30] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(67, 612, &[v_47, v_57, v_59])?; seed[31] = v_60.as_canonical_u64(); match v_51.as_canonical_u64() { 0u64 => { let [v_61]: [G; 1] = [G::from_u64(1)]; let [v_62]: [G; 1] = context.store(70, &[v_61, v_61, v_61])?; seed[32] = v_62.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(716, v_45)) }, } }, 7u64 => { let [v_64]: [G; 1] = [G::from_u64(1)]; let [v_65]: [G; 1] = context.store(75, &[v_64, v_64, v_64])?; seed[15] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = context.call::<1>(76, 517, &[v_2, v_65])?; seed[16] = v_66.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(716, v_0)) }, } } + +fn pack_716_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let [v_13]: [G; 1] = context.call::<1>(0, 594, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11])?; seed.full(48, v_13); match v_0.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(4, &[v_15, v_15, v_15])?; seed.u32(152, v_16); let [v_17]: [G; 1] = context.call::<1>(5, 517, &[v_2, v_16])?; seed.full(56, v_17); Ok(()) }, 1u64 => { let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(11, &[v_19, v_19, v_19])?; seed.u32(152, v_20); let [v_21]: [G; 1] = context.call::<1>(12, 517, &[v_2, v_20])?; seed.full(56, v_21); Ok(()) }, 2u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.store(20, &[v_23, v_23, v_23])?; seed.u32(152, v_24); let [v_25]: [G; 1] = context.call::<1>(21, 517, &[v_2, v_24])?; seed.full(56, v_25); let [v_26]: [G; 1] = context.store(22, &[v_22, v_22, v_22])?; seed.u32(156, v_26); let [v_27]: [G; 1] = context.call::<1>(23, 332, &[v_25, v_26])?; seed.u8(182, v_27); Ok(()) }, 3u64 => { let [v_29]: [G; 1] = [G::from_u64(1)]; let [v_30]: [G; 1] = context.store(32, &[v_29, v_29, v_29])?; seed.u32(152, v_30); let [v_31]: [G; 1] = context.call::<1>(33, 517, &[v_2, v_30])?; seed.full(56, v_31); Ok(()) }, 4u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; let [v_34]: [G; 1] = context.store(40, &[v_33, v_33, v_33])?; seed.u32(152, v_34); let [v_35]: [G; 1] = context.call::<1>(41, 517, &[v_2, v_34])?; seed.full(56, v_35); Ok(()) }, 5u64 => { let [v_37]: [G; 1] = [G::from_u64(1)]; let [v_38]: [G; 1] = context.store(47, &[v_37, v_37, v_37])?; seed.u32(152, v_38); let [v_39]: [G; 1] = context.call::<1>(48, 517, &[v_2, v_38])?; seed.full(56, v_39); Ok(()) }, 6u64 => { let [v_41]: [G; 1] = [G::from_u64(1)]; let [v_42]: [G; 1] = context.store(56, &[v_41, v_41, v_41])?; seed.u32(152, v_42); let [v_43]: [G; 1] = context.call::<1>(57, 517, &[v_2, v_42])?; seed.full(56, v_43); let [v_44]: [G; 1] = context.call::<1>(59, 297, &[v_3, v_4])?; seed.u32(156, v_44); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 12] = context.load::<12>(60, v_44)?; seed.u8(182, v_45); seed.full(64, v_46); seed.u32(160, v_47); seed.full(72, v_48); seed.full(80, v_49); seed.full(88, v_50); seed.full(96, v_51); seed.full(104, v_52); seed.full(112, v_53); seed.full(120, v_54); seed.full(128, v_55); seed.full(136, v_56); match v_45.as_canonical_u64() { 5u64 => { let [v_57]: [G; 1] = [v_48 + v_49]; let [v_58]: [G; 1] = [G::from_u64(1)]; let [v_59]: [G; 1] = context.store(66, &[v_58, v_58, v_58])?; seed.u32(164, v_59); let [v_60]: [G; 1] = context.call::<1>(67, 612, &[v_47, v_57, v_59])?; seed.u32(168, v_60); match v_51.as_canonical_u64() { 0u64 => { let [v_61]: [G; 1] = [G::from_u64(1)]; let [v_62]: [G; 1] = context.store(70, &[v_61, v_61, v_61])?; seed.u32(172, v_62); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(716, v_45)) }, } }, 7u64 => { let [v_64]: [G; 1] = [G::from_u64(1)]; let [v_65]: [G; 1] = context.store(75, &[v_64, v_64, v_64])?; seed.u32(152, v_65); let [v_66]: [G; 1] = context.call::<1>(76, 517, &[v_2, v_65])?; seed.full(56, v_66); Ok(()) }, _ => { Err(no_match(716, v_0)) }, } } + +fn pack_716_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let [v_13]: [G; 1] = context.call::<1>(0, 594, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11])?; seed[14] = v_13.as_canonical_u64(); match v_0.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(4, &[v_15, v_15, v_15])?; seed[15] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(5, 517, &[v_2, v_16])?; seed[16] = v_17.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(11, &[v_19, v_19, v_19])?; seed[15] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(12, 517, &[v_2, v_20])?; seed[16] = v_21.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.store(20, &[v_23, v_23, v_23])?; seed[15] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = context.call::<1>(21, 517, &[v_2, v_24])?; seed[16] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.store(22, &[v_22, v_22, v_22])?; seed[17] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = context.call::<1>(23, 332, &[v_25, v_26])?; seed[18] = v_27.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_29]: [G; 1] = [G::from_u64(1)]; let [v_30]: [G; 1] = context.store(32, &[v_29, v_29, v_29])?; seed[15] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(33, 517, &[v_2, v_30])?; seed[16] = v_31.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; let [v_34]: [G; 1] = context.store(40, &[v_33, v_33, v_33])?; seed[15] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.call::<1>(41, 517, &[v_2, v_34])?; seed[16] = v_35.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_37]: [G; 1] = [G::from_u64(1)]; let [v_38]: [G; 1] = context.store(47, &[v_37, v_37, v_37])?; seed[15] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.call::<1>(48, 517, &[v_2, v_38])?; seed[16] = v_39.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_41]: [G; 1] = [G::from_u64(1)]; let [v_42]: [G; 1] = context.store(56, &[v_41, v_41, v_41])?; seed[15] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.call::<1>(57, 517, &[v_2, v_42])?; seed[16] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(59, 297, &[v_3, v_4])?; seed[17] = v_44.as_canonical_u64(); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 12] = context.load::<12>(60, v_44)?; seed[18] = v_45.as_canonical_u64(); seed[19] = v_46.as_canonical_u64(); seed[20] = v_47.as_canonical_u64(); seed[21] = v_48.as_canonical_u64(); seed[22] = v_49.as_canonical_u64(); seed[23] = v_50.as_canonical_u64(); seed[24] = v_51.as_canonical_u64(); seed[25] = v_52.as_canonical_u64(); seed[26] = v_53.as_canonical_u64(); seed[27] = v_54.as_canonical_u64(); seed[28] = v_55.as_canonical_u64(); seed[29] = v_56.as_canonical_u64(); match v_45.as_canonical_u64() { 5u64 => { let [v_57]: [G; 1] = [v_48 + v_49]; let [v_58]: [G; 1] = [G::from_u64(1)]; let [v_59]: [G; 1] = context.store(66, &[v_58, v_58, v_58])?; seed[30] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(67, 612, &[v_47, v_57, v_59])?; seed[31] = v_60.as_canonical_u64(); match v_51.as_canonical_u64() { 0u64 => { let [v_61]: [G; 1] = [G::from_u64(1)]; let [v_62]: [G; 1] = context.store(70, &[v_61, v_61, v_61])?; seed[32] = v_62.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(716, v_45)) }, } }, 7u64 => { let [v_64]: [G; 1] = [G::from_u64(1)]; let [v_65]: [G; 1] = context.store(75, &[v_64, v_64, v_64])?; seed[15] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = context.call::<1>(76, 517, &[v_2, v_65])?; seed[16] = v_66.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(716, v_0)) }, } } + +fn write_716(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let [v_13]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 1] = v_13.as_canonical_u64(); match v_0.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_24]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 4] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 5] = v_27.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_30]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_31.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_34]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_35.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_39.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_42]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 4] = v_44.as_canonical_u64(); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 12] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29])]; row[offsets.auxiliaries + 5] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_56.as_canonical_u64(); match v_45.as_canonical_u64() { 5u64 => { let [v_59]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 17] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 18] = v_60.as_canonical_u64(); match v_51.as_canonical_u64() { 0u64 => { let [v_62]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 19] = v_62.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 19] = (v_51 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(716, v_45)) }, } }, 7u64 => { let [v_65]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_66.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(716, v_0)) }, } } + +static SCHEMA_716: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 176, 177, 144, 178, 8, 16, 24, 179, 180, 32, 181, 40, 148, 48, 152, 56, 156, 182, 64, 160, 72, 80, 88, 96, 104, 112, 120, 128, 136, 164, 168, 172], bytes: 184 }; + +fn pack_724(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_3 - v_1]; match v_6.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_8]: [G; 1] = context.returned::<1>(4)?; seed[6] = v_8.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(724, v_2)) }, } } + +fn pack_724_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_2); seed.full(16, v_3); seed.u32(28, v_4); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_3 - v_1]; match v_6.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_8]: [G; 1] = context.returned::<1>(4)?; seed.u8(33, v_8); Ok(()) }, } }, _ => { Err(no_match(724, v_2)) }, } } + +fn pack_724_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_3 - v_1]; match v_6.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_8]: [G; 1] = context.check_returned::<1>(4, 724, &[v_4, v_1])?; seed[6] = v_8.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(724, v_2)) }, } } + +fn write_724(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_3 - v_1]; match v_6.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 4] = (v_6 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(724, v_2)) }, } } + +static SCHEMA_724: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 24, 8, 32, 16, 28, 33], bytes: 40 }; + +fn pack_726(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 724, &[v_1, v_2])?; seed[7] = v_6.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(726, v_3)) }, } } + +fn pack_726_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(28, v_3); seed.u8(29, v_4); seed.u32(24, v_5); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 724, &[v_1, v_2])?; seed.u8(30, v_6); Ok(()) }, _ => { Err(no_match(726, v_3)) }, } } + +fn pack_726_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 724, &[v_1, v_2])?; seed[7] = v_6.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(726, v_3)) }, } } + +fn write_726(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_6.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, _ => { row[offsets.auxiliaries + 5] = (v_6 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(726, v_3)) }, } } + +static SCHEMA_726: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 16, 20, 8, 28, 29, 24, 30], bytes: 32 }; + +fn pack_780(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.store(4, &[v_5, v_1, v_7])?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.call::<1>(6, 780, &[v_4, v_1])?; seed[6] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.store(7, &[v_9, v_3, v_10])?; seed[7] = v_11.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(780, v_2)) }, } } + +fn pack_780_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(40, v_2); seed.full(16, v_3); seed.u32(28, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6])?; seed.u32(32, v_7); let [v_8]: [G; 1] = context.store(4, &[v_5, v_1, v_7])?; seed.u32(36, v_8); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.call::<1>(6, 780, &[v_4, v_1])?; seed.u32(32, v_10); let [v_11]: [G; 1] = context.store(7, &[v_9, v_3, v_10])?; seed.u32(36, v_11); Ok(()) }, _ => { Err(no_match(780, v_2)) }, } } + +fn pack_780_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.store(4, &[v_5, v_1, v_7])?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.call::<1>(6, 780, &[v_4, v_1])?; seed[6] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.store(7, &[v_9, v_3, v_10])?; seed[7] = v_11.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(780, v_2)) }, } } + +fn write_780(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_11.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(780, v_2)) }, } } + +static SCHEMA_780: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 24, 8, 40, 16, 28, 32, 36], bytes: 48 }; + +fn pack_786(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = context.call::<1>(2, 786, &[v_4, v_1])?; seed[6] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = context.store(3, &[v_5, v_3, v_6])?; seed[7] = v_7.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(786, v_2)) }, } } + +fn pack_786_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(44, v_2); seed.full(16, v_3); seed.u32(36, v_4); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = context.call::<1>(2, 786, &[v_4, v_1])?; seed.full(24, v_6); let [v_7]: [G; 1] = context.store(3, &[v_5, v_3, v_6])?; seed.u32(40, v_7); Ok(()) }, _ => { Err(no_match(786, v_2)) }, } } + +fn pack_786_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = context.call::<1>(2, 786, &[v_4, v_1])?; seed[6] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = context.store(3, &[v_5, v_3, v_6])?; seed[7] = v_7.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(786, v_2)) }, } } + +fn write_786(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(786, v_2)) }, } } + +static SCHEMA_786: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 32, 8, 44, 16, 36, 24, 40], bytes: 48 }; + +fn pack_789(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 798, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_2)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_789_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 798, &[v_0, v_1])?; seed.u32(40, v_2); let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_2)?; seed.u8(44, v_3); seed.full(24, v_4); seed.full(32, v_5); Ok(()) } + +fn pack_789_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 798, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_2)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); Ok(()) } + +fn write_789(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); let [v_3, v_4, v_5]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(789, v_3)) }, } } + +static SCHEMA_789: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 40, 44, 24, 32], bytes: 48 }; + +fn pack_798(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = [v_1 - v_2]; let [v_4]: [G; 1] = context.call::<1>(2, 798, &[v_0, v_3])?; seed[3] = v_4.as_canonical_u64(); let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(3, v_4)?; seed[4] = v_5.as_canonical_u64(); seed[5] = v_6.as_canonical_u64(); seed[6] = v_7.as_canonical_u64(); Ok(()) }, } } + +fn pack_798_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = [v_1 - v_2]; let [v_4]: [G; 1] = context.call::<1>(2, 798, &[v_0, v_3])?; seed.u32(40, v_4); let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(3, v_4)?; seed.u8(44, v_5); seed.full(24, v_6); seed.full(32, v_7); Ok(()) }, } } + +fn pack_798_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = [v_1 - v_2]; let [v_4]: [G; 1] = context.call::<1>(2, 798, &[v_0, v_3])?; seed[3] = v_4.as_canonical_u64(); let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(3, v_4)?; seed[4] = v_5.as_canonical_u64(); seed[5] = v_6.as_canonical_u64(); seed[6] = v_7.as_canonical_u64(); Ok(()) }, } } + +fn write_798(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); let [v_5, v_6, v_7]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(798, v_5)) }, } }, } } + +static SCHEMA_798: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 40, 44, 24, 32], bytes: 48 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(256)), Op::Mul(9, 66), Op::Add(67, 8), Op::Mul(68, 66), Op::Add(69, 7), Op::Mul(70, 66), Op::Add(71, 6), Op::Mul(72, 66), Op::Add(73, 5), Op::Mul(74, 66), Op::Add(75, 4), Op::Mul(76, 66), Op::Add(77, 3), Op::Mul(41, 66), Op::Add(79, 40), Op::Mul(80, 66), Op::Add(81, 39), Op::Mul(82, 66), Op::Add(83, 38), Op::Mul(84, 66), Op::Add(85, 37), Op::Mul(86, 66), Op::Add(87, 36), Op::Mul(88, 66), Op::Add(89, 35), Op::Sub(78, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 92), Op::Add(93, 15), Op::Mul(94, 92), Op::Add(95, 14), Op::Mul(96, 92), Op::Add(97, 13), Op::Mul(98, 92), Op::Add(99, 12), Op::Mul(100, 92), Op::Add(101, 11), Op::Mul(102, 92), Op::Add(103, 10), Op::Mul(48, 92), Op::Add(105, 47), Op::Mul(106, 92), Op::Add(107, 46), Op::Mul(108, 92), Op::Add(109, 45), Op::Mul(110, 92), Op::Add(111, 44), Op::Mul(112, 92), Op::Add(113, 43), Op::Mul(114, 92), Op::Add(115, 42), Op::Sub(104, 116)], ctrl: Ctrl::Match(117, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(23, 118), Op::Add(119, 22), Op::Mul(120, 118), Op::Add(121, 21), Op::Mul(122, 118), Op::Add(123, 20), Op::Mul(124, 118), Op::Add(125, 19), Op::Mul(126, 118), Op::Add(127, 18), Op::Mul(128, 118), Op::Add(129, 17), Op::Mul(55, 118), Op::Add(131, 54), Op::Mul(132, 118), Op::Add(133, 53), Op::Mul(134, 118), Op::Add(135, 52), Op::Mul(136, 118), Op::Add(137, 51), Op::Mul(138, 118), Op::Add(139, 50), Op::Mul(140, 118), Op::Add(141, 49), Op::Sub(130, 142)], ctrl: Ctrl::Match(143, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(30, 144), Op::Add(145, 29), Op::Mul(146, 144), Op::Add(147, 28), Op::Mul(148, 144), Op::Add(149, 27), Op::Mul(150, 144), Op::Add(151, 26), Op::Mul(152, 144), Op::Add(153, 25), Op::Mul(154, 144), Op::Add(155, 24), Op::Mul(62, 144), Op::Add(157, 61), Op::Mul(158, 144), Op::Add(159, 60), Op::Mul(160, 144), Op::Add(161, 59), Op::Mul(162, 144), Op::Add(163, 58), Op::Mul(164, 144), Op::Add(165, 57), Op::Mul(166, 144), Op::Add(167, 56), Op::Sub(156, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(33, 170), Op::Add(171, 32), Op::Mul(172, 170), Op::Add(173, 31), Op::Mul(65, 170), Op::Add(175, 64), Op::Mul(176, 170), Op::Add(177, 63), Op::Sub(174, 178)], ctrl: Ctrl::Match(179, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![180]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![180]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![170]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![144]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![118]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![92]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 66, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Sub(2, 34)], ctrl: Ctrl::Match(66, [(G::from_u64(0), Block { ops: vec![Op::Call(1, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![67]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![67]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 66, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(4294967295)), Op::Call(0, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![2], vec![3], Some("list depth exceeds u32".into())), Op::Add(0, 3)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Sub(2, 3), Op::Call(4, vec![0, 4, 5], 1, false), Op::IORead(0, 1, 1), Op::Const(G::from_u64(0)), Op::Store(vec![8, 7, 6])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![Op::Call(4, vec![0, 1, 2], 1, true), Op::Call(800, vec![3], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(3, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(4, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(5, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(6, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(7, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(8, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(9, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(10, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(11, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(12, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(13, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(14, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(15, vec![8]) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(16, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(17, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(18, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(19, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(20, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(21, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(22, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(23, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(24, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(25, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(26, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(27, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(28, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(29, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(30, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(31, vec![8]) }))) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(32, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(33, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(34, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(35, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(36, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(37, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(38, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(39, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(40, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(41, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(42, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(43, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(44, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(45, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(46, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(47, vec![8]) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(48, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(49, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(50, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(51, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(52, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(53, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(54, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(55, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(56, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(57, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(58, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(59, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(60, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(61, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(62, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(63, vec![8]) }))) }))) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(64, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(65, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(66, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(67, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(68, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(69, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(70, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(71, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(72, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(73, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(74, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(75, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(76, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(77, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(78, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(79, vec![8]) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(80, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(81, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(82, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(83, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(84, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(85, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(86, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(87, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(88, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(89, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(90, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(91, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(92, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(93, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(94, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(95, vec![8]) }))) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(96, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(97, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(98, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(99, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(100, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(101, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(102, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(103, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(104, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(105, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(106, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(107, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(108, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(109, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(110, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(111, vec![8]) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(112, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(113, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(114, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(115, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(116, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(117, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(118, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(119, vec![8]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(120, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(121, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(122, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(123, vec![8]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(124, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(125, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(126, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(127, vec![8]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 8, selectors: 128, auxiliaries: 8, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Mul(12, 12), Op::AssertEq(vec![13], vec![12], Some("u32_add: carry is not boolean".into()))], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::U8RangeCheck(12, 13), Op::U8RangeCheck(14, 15), Op::Const(G::from_u64(1)), Op::Sub(16, 17), Op::Const(G::from_u64(2)), Op::Sub(16, 19), Op::Mul(18, 20), Op::Mul(16, 21), Op::Const(G::from_u64(0)), Op::AssertEq(vec![22], vec![23], Some("u32_add3: carry is not in {0, 1, 2}".into()))], ctrl: Ctrl::Return(0, vec![12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 4), Op::U8Xor(1, 5), Op::U8Xor(2, 6), Op::U8Xor(3, 7)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 0, 1]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 0]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit7(0, 4), Op::U8XorSplit7(1, 5), Op::U8XorSplit7(2, 6), Op::U8XorSplit7(3, 7), Op::Add(8, 11), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit4(0, 4), Op::U8XorSplit4(1, 5), Op::U8XorSplit4(2, 6), Op::U8XorSplit4(3, 7), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9), Op::Add(8, 11)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 8), Op::Sub(1, 9), Op::Sub(2, 10), Op::Sub(3, 11), Op::Sub(4, 12), Op::Sub(5, 13), Op::Sub(6, 14), Op::Sub(7, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![24]) }))) }, layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![Op::U8Add(0, 8), Op::U8Add(1, 9), Op::U8Add(18, 17), Op::Add(19, 21), Op::U8Add(2, 10), Op::U8Add(23, 22), Op::Add(24, 26), Op::U8Add(3, 11), Op::U8Add(28, 27), Op::Add(29, 31), Op::U8Add(4, 12), Op::U8Add(33, 32), Op::Add(34, 36), Op::U8Add(5, 13), Op::U8Add(38, 37), Op::Add(39, 41), Op::U8Add(6, 14), Op::U8Add(43, 42), Op::Add(44, 46), Op::U8Add(7, 15), Op::U8Add(48, 47), Op::Add(49, 51)], ctrl: Ctrl::Return(0, vec![16, 20, 25, 30, 35, 40, 45, 50, 52]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(255), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".into())), Op::Const(G::from_u64(256)), Op::Mul(9, 1), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Const(G::from_u64(16777216)), Op::Mul(13, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 6), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(0, 25)], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(4, 1), Op::Const(G::from_u64(65536)), Op::Mul(6, 2), Op::Const(G::from_u64(16777216)), Op::Mul(8, 3), Op::Add(7, 9), Op::Add(5, 10), Op::Add(0, 11)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(32, 1), Op::Const(G::from_u64(65536)), Op::Mul(34, 2), Op::Const(G::from_u64(16777216)), Op::Mul(36, 3), Op::Add(35, 37), Op::Add(33, 38), Op::Add(0, 39), Op::Mul(32, 5), Op::Mul(34, 6), Op::Mul(36, 7), Op::Add(42, 43), Op::Add(41, 44), Op::Add(4, 45), Op::Mul(32, 9), Op::Mul(34, 10), Op::Mul(36, 11), Op::Add(48, 49), Op::Add(47, 50), Op::Add(8, 51), Op::Mul(32, 13), Op::Mul(34, 14), Op::Mul(36, 15), Op::Add(54, 55), Op::Add(53, 56), Op::Add(12, 57), Op::Mul(32, 17), Op::Mul(34, 18), Op::Mul(36, 19), Op::Add(60, 61), Op::Add(59, 62), Op::Add(16, 63), Op::Mul(32, 21), Op::Mul(34, 22), Op::Mul(36, 23), Op::Add(66, 67), Op::Add(65, 68), Op::Add(20, 69), Op::Mul(32, 25), Op::Mul(34, 26), Op::Mul(36, 27), Op::Add(72, 73), Op::Add(71, 74), Op::Add(24, 75), Op::Mul(32, 29), Op::Mul(34, 30), Op::Mul(36, 31), Op::Add(78, 79), Op::Add(77, 80), Op::Add(28, 81)], ctrl: Ctrl::Return(0, vec![40, 46, 52, 58, 64, 70, 76, 82]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_22() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(27, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(26, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_23() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![64, 64, 64]), Op::Const(G::from_u64(0)), Op::Store(vec![66, 66, 66, 66, 66, 66, 66, 66]), Op::Store(vec![33, 34, 35, 36, 37, 38, 33, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63]), Op::Store(vec![64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64]), Op::Call(27, vec![0, 65, 66, 66, 67, 68, 69], 1, false), Op::Call(26, vec![70], 32, false), Op::AssertEq(vec![71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102], vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], Some("blake3 of the supplied bytes != the address they were fetched under".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_24() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(27, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(26, vec![38], 32, false), Op::Store(vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70])], ctrl: Ctrl::Return(0, vec![71]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 39, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_25() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(34, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![68, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(25, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68], 34, false)], ctrl: Ctrl::Match(69, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![103, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 102]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(34, 102)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Mul(104, 33), Op::Add(103, 170), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(35, vec![172, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 174, 175, 176, 177, 178, 179, 174, 180, 181, 182, 183, 184, 185, 186, 187, 188, 172, 172, 172, 172, 172, 172, 172, 172, 173, 172, 172, 172, 171, 172, 172, 172, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![172, 102, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220])], ctrl: Ctrl::Return(2, vec![172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 221]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(35, vec![170, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 172, 173, 174, 175, 176, 177, 172, 178, 179, 180, 181, 182, 183, 184, 185, 186, 170, 170, 170, 170, 170, 170, 170, 170, 171, 170, 170, 170, 103, 170, 170, 170, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![170, 102, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218])], ctrl: Ctrl::Return(3, vec![170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 219]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_26() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(34, 2)], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(25, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 69], 34, false)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Call(26, vec![103], 32, false)], ctrl: Ctrl::Return(1, vec![104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![104, 103, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102]), Op::Call(26, vec![105], 32, false)], ctrl: Ctrl::Return(2, vec![106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_27() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(30, vec![1, 2, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 1])], ctrl: Ctrl::Match(2, [(G::from_u64(63), Block { ops: vec![Op::Call(31, vec![9, 11, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 12), Op::Add(3, 12), Op::Call(27, vec![9, 11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_28() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 96)], ctrl: Ctrl::Match(97, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 99)], ctrl: Ctrl::Match(100, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 102)], ctrl: Ctrl::Match(103, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 105)], ctrl: Ctrl::Match(106, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 108)], ctrl: Ctrl::Match(109, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 111)], ctrl: Ctrl::Match(112, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 114)], ctrl: Ctrl::Match(115, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 117)], ctrl: Ctrl::Match(118, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 123)], ctrl: Ctrl::Match(124, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 126)], ctrl: Ctrl::Match(127, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 129)], ctrl: Ctrl::Match(130, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 132)], ctrl: Ctrl::Match(133, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 135)], ctrl: Ctrl::Match(136, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 138)], ctrl: Ctrl::Match(139, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 141)], ctrl: Ctrl::Match(142, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 144)], ctrl: Ctrl::Match(145, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 147)], ctrl: Ctrl::Match(148, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 150)], ctrl: Ctrl::Match(151, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 153)], ctrl: Ctrl::Match(154, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 156)], ctrl: Ctrl::Match(157, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 159)], ctrl: Ctrl::Match(160, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 165)], ctrl: Ctrl::Match(166, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 171)], ctrl: Ctrl::Match(172, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 174)], ctrl: Ctrl::Match(175, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 177)], ctrl: Ctrl::Match(178, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 180)], ctrl: Ctrl::Match(181, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 183)], ctrl: Ctrl::Match(184, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 186)], ctrl: Ctrl::Match(187, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 189)], ctrl: Ctrl::Match(190, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 29, 26, 23, 20, 17, 14, 11, 8, 5, 2]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_29() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(29, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_30() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Add(6, 7), Op::Add(8, 17), Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(35, vec![51, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 60, 61, 62, 63, 64, 65, 60, 66, 67, 68, 69, 70, 71, 72, 73, 74, 52, 53, 54, 55, 56, 57, 58, 59, 51, 51, 51, 51, 18, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51], 32, false), Op::Store(vec![51, 5, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106])], ctrl: Ctrl::Return(0, vec![107]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Load(32, 4), Op::Store(vec![9, 5, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41])], ctrl: Ctrl::Return(9, vec![42]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(8, 3), Op::Call(7, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Sub(2, 1), Op::EqZero(19), Op::Mul(20, 6), Op::Add(18, 21), Op::Add(7, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(29, vec![0, 25], 1, false), Op::Call(28, vec![26], 64, false), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(35, vec![138, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 123, 129, 130, 131, 132, 133, 134, 135, 136, 137, 9, 10, 11, 12, 13, 14, 15, 16, 1, 138, 138, 138, 23, 138, 138, 138, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90], 32, false), Op::Store(vec![138, 5, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170])], ctrl: Ctrl::Return(10, vec![171]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_31() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(28, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(795, vec![0], 1, false), Op::Load(8, 3), Op::Call(7, vec![74, 75, 76, 77, 78, 79, 80, 81], 1, false), Op::Mul(73, 82), Op::Mul(8, 83), Op::Add(84, 7), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(0)), Op::Call(35, vec![150, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 74, 75, 76, 77, 78, 79, 80, 81, 149, 150, 150, 150, 85, 150, 150, 150, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Store(vec![150, 5, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182]), Op::Const(G::from_u64(1)), Op::Store(vec![184, 184, 184]), Op::Call(17, vec![74, 75, 76, 77, 78, 79, 80, 81], 8, false), Op::Store(vec![186, 187, 188, 189, 190, 191, 192, 193]), Op::Store(vec![86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]), Op::Call(27, vec![0, 185, 150, 150, 194, 195, 183], 1, false)], ctrl: Ctrl::Return(0, vec![196]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(795, vec![0], 1, false), Op::Mul(73, 7), Op::Call(795, vec![0], 1, false), Op::Load(8, 3), Op::Call(7, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(84, 8), Op::Mul(75, 85), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(86, 90), Op::Add(74, 91), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(35, vec![141, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 126, 127, 128, 129, 130, 131, 126, 132, 133, 134, 135, 136, 137, 138, 139, 140, 76, 77, 78, 79, 80, 81, 82, 83, 125, 141, 141, 141, 92, 141, 141, 141, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Const(G::from_u64(1)), Op::Store(vec![174, 174, 174]), Op::Add(2, 174), Op::Store(vec![142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173]), Op::Call(27, vec![0, 175, 141, 176, 3, 177, 5], 1, false)], ctrl: Ctrl::Return(1, vec![178]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_32() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![16, 17, 18, 19]), Op::U8RangeCheck(24, 25), Op::U8RangeCheck(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Const(G::from_u64(2)), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(28, 33), Op::Const(G::from_u64(0)), Op::AssertEq(vec![34], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(12, 24), Op::U8Xor(13, 25), Op::U8Xor(14, 26), Op::U8Xor(15, 27), Op::UnconstrainedU32Add(vec![8, 9, 10, 11], vec![38, 39, 36, 37]), Op::U8RangeCheck(40, 41), Op::U8RangeCheck(42, 43), Op::Mul(44, 44), Op::AssertEq(vec![45], vec![44], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(4, 40), Op::U8XorSplit4(5, 41), Op::U8XorSplit4(6, 42), Op::U8XorSplit4(7, 43), Op::Add(48, 51), Op::Add(50, 53), Op::Add(52, 47), Op::Add(46, 49), Op::UnconstrainedU32Add3(vec![24, 25, 26, 27], vec![54, 55, 56, 57], vec![20, 21, 22, 23]), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::Sub(62, 29), Op::Sub(62, 31), Op::Mul(63, 64), Op::Mul(62, 65), Op::AssertEq(vec![66], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(38, 58), Op::U8Xor(39, 59), Op::U8Xor(36, 60), Op::U8Xor(37, 61), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![68, 69, 70, 67]), Op::U8RangeCheck(71, 72), Op::U8RangeCheck(73, 74), Op::Mul(75, 75), Op::AssertEq(vec![76], vec![75], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(54, 71), Op::U8XorSplit7(55, 72), Op::U8XorSplit7(56, 73), Op::U8XorSplit7(57, 74), Op::Add(77, 80), Op::Add(79, 82), Op::Add(81, 84), Op::Add(83, 78)], ctrl: Ctrl::Return(0, vec![58, 59, 60, 61, 85, 86, 87, 88, 71, 72, 73, 74, 68, 69, 70, 67]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 47, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_33() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![16, 17, 18, 19], vec![64, 65, 66, 67]), Op::U8RangeCheck(128, 129), Op::U8RangeCheck(130, 131), Op::Const(G::from_u64(1)), Op::Sub(132, 133), Op::Const(G::from_u64(2)), Op::Sub(132, 135), Op::Mul(134, 136), Op::Mul(132, 137), Op::Const(G::from_u64(0)), Op::AssertEq(vec![138], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(48, 128), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::UnconstrainedU32Add(vec![32, 33, 34, 35], vec![142, 143, 140, 141]), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::Mul(148, 148), Op::AssertEq(vec![149], vec![148], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(16, 144), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::Add(152, 155), Op::Add(154, 157), Op::Add(156, 151), Op::Add(150, 153), Op::UnconstrainedU32Add3(vec![128, 129, 130, 131], vec![158, 159, 160, 161], vec![68, 69, 70, 71]), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::Sub(166, 133), Op::Sub(166, 135), Op::Mul(167, 168), Op::Mul(166, 169), Op::AssertEq(vec![170], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(142, 162), Op::U8Xor(143, 163), Op::U8Xor(140, 164), Op::U8Xor(141, 165), Op::UnconstrainedU32Add(vec![144, 145, 146, 147], vec![172, 173, 174, 171]), Op::U8RangeCheck(175, 176), Op::U8RangeCheck(177, 178), Op::Mul(179, 179), Op::AssertEq(vec![180], vec![179], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(158, 175), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::Add(181, 184), Op::Add(183, 186), Op::Add(185, 188), Op::Add(187, 182), Op::UnconstrainedU32Add3(vec![4, 5, 6, 7], vec![20, 21, 22, 23], vec![72, 73, 74, 75]), Op::U8RangeCheck(193, 194), Op::U8RangeCheck(195, 196), Op::Sub(197, 133), Op::Sub(197, 135), Op::Mul(198, 199), Op::Mul(197, 200), Op::AssertEq(vec![201], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(52, 193), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::UnconstrainedU32Add(vec![36, 37, 38, 39], vec![204, 205, 202, 203]), Op::U8RangeCheck(206, 207), Op::U8RangeCheck(208, 209), Op::Mul(210, 210), Op::AssertEq(vec![211], vec![210], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(20, 206), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::Add(214, 217), Op::Add(216, 219), Op::Add(218, 213), Op::Add(212, 215), Op::UnconstrainedU32Add3(vec![193, 194, 195, 196], vec![220, 221, 222, 223], vec![76, 77, 78, 79]), Op::U8RangeCheck(224, 225), Op::U8RangeCheck(226, 227), Op::Sub(228, 133), Op::Sub(228, 135), Op::Mul(229, 230), Op::Mul(228, 231), Op::AssertEq(vec![232], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(204, 224), Op::U8Xor(205, 225), Op::U8Xor(202, 226), Op::U8Xor(203, 227), Op::UnconstrainedU32Add(vec![206, 207, 208, 209], vec![234, 235, 236, 233]), Op::U8RangeCheck(237, 238), Op::U8RangeCheck(239, 240), Op::Mul(241, 241), Op::AssertEq(vec![242], vec![241], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(220, 237), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::Add(243, 246), Op::Add(245, 248), Op::Add(247, 250), Op::Add(249, 244), Op::UnconstrainedU32Add3(vec![8, 9, 10, 11], vec![24, 25, 26, 27], vec![80, 81, 82, 83]), Op::U8RangeCheck(255, 256), Op::U8RangeCheck(257, 258), Op::Sub(259, 133), Op::Sub(259, 135), Op::Mul(260, 261), Op::Mul(259, 262), Op::AssertEq(vec![263], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(56, 255), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![266, 267, 264, 265]), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::Mul(272, 272), Op::AssertEq(vec![273], vec![272], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(24, 268), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::Add(276, 279), Op::Add(278, 281), Op::Add(280, 275), Op::Add(274, 277), Op::UnconstrainedU32Add3(vec![255, 256, 257, 258], vec![282, 283, 284, 285], vec![84, 85, 86, 87]), Op::U8RangeCheck(286, 287), Op::U8RangeCheck(288, 289), Op::Sub(290, 133), Op::Sub(290, 135), Op::Mul(291, 292), Op::Mul(290, 293), Op::AssertEq(vec![294], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(266, 286), Op::U8Xor(267, 287), Op::U8Xor(264, 288), Op::U8Xor(265, 289), Op::UnconstrainedU32Add(vec![268, 269, 270, 271], vec![296, 297, 298, 295]), Op::U8RangeCheck(299, 300), Op::U8RangeCheck(301, 302), Op::Mul(303, 303), Op::AssertEq(vec![304], vec![303], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(282, 299), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::Add(305, 308), Op::Add(307, 310), Op::Add(309, 312), Op::Add(311, 306), Op::UnconstrainedU32Add3(vec![12, 13, 14, 15], vec![28, 29, 30, 31], vec![88, 89, 90, 91]), Op::U8RangeCheck(317, 318), Op::U8RangeCheck(319, 320), Op::Sub(321, 133), Op::Sub(321, 135), Op::Mul(322, 323), Op::Mul(321, 324), Op::AssertEq(vec![325], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(60, 317), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::UnconstrainedU32Add(vec![44, 45, 46, 47], vec![328, 329, 326, 327]), Op::U8RangeCheck(330, 331), Op::U8RangeCheck(332, 333), Op::Mul(334, 334), Op::AssertEq(vec![335], vec![334], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(28, 330), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::Add(338, 341), Op::Add(340, 343), Op::Add(342, 337), Op::Add(336, 339), Op::UnconstrainedU32Add3(vec![317, 318, 319, 320], vec![344, 345, 346, 347], vec![92, 93, 94, 95]), Op::U8RangeCheck(348, 349), Op::U8RangeCheck(350, 351), Op::Sub(352, 133), Op::Sub(352, 135), Op::Mul(353, 354), Op::Mul(352, 355), Op::AssertEq(vec![356], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(328, 348), Op::U8Xor(329, 349), Op::U8Xor(326, 350), Op::U8Xor(327, 351), Op::UnconstrainedU32Add(vec![330, 331, 332, 333], vec![358, 359, 360, 357]), Op::U8RangeCheck(361, 362), Op::U8RangeCheck(363, 364), Op::Mul(365, 365), Op::AssertEq(vec![366], vec![365], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(344, 361), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::Add(367, 370), Op::Add(369, 372), Op::Add(371, 374), Op::Add(373, 368), Op::UnconstrainedU32Add3(vec![162, 163, 164, 165], vec![251, 252, 253, 254], vec![96, 97, 98, 99]), Op::U8RangeCheck(379, 380), Op::U8RangeCheck(381, 382), Op::Sub(383, 133), Op::Sub(383, 135), Op::Mul(384, 385), Op::Mul(383, 386), Op::AssertEq(vec![387], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(358, 379), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(357, 382), Op::UnconstrainedU32Add(vec![299, 300, 301, 302], vec![390, 391, 388, 389]), Op::U8RangeCheck(392, 393), Op::U8RangeCheck(394, 395), Op::Mul(396, 396), Op::AssertEq(vec![397], vec![396], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(251, 392), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::Add(400, 403), Op::Add(402, 405), Op::Add(404, 399), Op::Add(398, 401), Op::UnconstrainedU32Add3(vec![379, 380, 381, 382], vec![406, 407, 408, 409], vec![100, 101, 102, 103]), Op::U8RangeCheck(410, 411), Op::U8RangeCheck(412, 413), Op::Sub(414, 133), Op::Sub(414, 135), Op::Mul(415, 416), Op::Mul(414, 417), Op::AssertEq(vec![418], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(390, 410), Op::U8Xor(391, 411), Op::U8Xor(388, 412), Op::U8Xor(389, 413), Op::UnconstrainedU32Add(vec![392, 393, 394, 395], vec![420, 421, 422, 419]), Op::U8RangeCheck(423, 424), Op::U8RangeCheck(425, 426), Op::Mul(427, 427), Op::AssertEq(vec![428], vec![427], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(406, 423), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::Add(429, 432), Op::Add(431, 434), Op::Add(433, 436), Op::Add(435, 430), Op::UnconstrainedU32Add3(vec![224, 225, 226, 227], vec![313, 314, 315, 316], vec![104, 105, 106, 107]), Op::U8RangeCheck(441, 442), Op::U8RangeCheck(443, 444), Op::Sub(445, 133), Op::Sub(445, 135), Op::Mul(446, 447), Op::Mul(445, 448), Op::AssertEq(vec![449], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(172, 441), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(171, 444), Op::UnconstrainedU32Add(vec![361, 362, 363, 364], vec![452, 453, 450, 451]), Op::U8RangeCheck(454, 455), Op::U8RangeCheck(456, 457), Op::Mul(458, 458), Op::AssertEq(vec![459], vec![458], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(313, 454), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::Add(462, 465), Op::Add(464, 467), Op::Add(466, 461), Op::Add(460, 463), Op::UnconstrainedU32Add3(vec![441, 442, 443, 444], vec![468, 469, 470, 471], vec![108, 109, 110, 111]), Op::U8RangeCheck(472, 473), Op::U8RangeCheck(474, 475), Op::Sub(476, 133), Op::Sub(476, 135), Op::Mul(477, 478), Op::Mul(476, 479), Op::AssertEq(vec![480], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(452, 472), Op::U8Xor(453, 473), Op::U8Xor(450, 474), Op::U8Xor(451, 475), Op::UnconstrainedU32Add(vec![454, 455, 456, 457], vec![482, 483, 484, 481]), Op::U8RangeCheck(485, 486), Op::U8RangeCheck(487, 488), Op::Mul(489, 489), Op::AssertEq(vec![490], vec![489], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(468, 485), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::Add(491, 494), Op::Add(493, 496), Op::Add(495, 498), Op::Add(497, 492), Op::UnconstrainedU32Add3(vec![286, 287, 288, 289], vec![375, 376, 377, 378], vec![112, 113, 114, 115]), Op::U8RangeCheck(503, 504), Op::U8RangeCheck(505, 506), Op::Sub(507, 133), Op::Sub(507, 135), Op::Mul(508, 509), Op::Mul(507, 510), Op::AssertEq(vec![511], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(234, 503), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(233, 506), Op::UnconstrainedU32Add(vec![175, 176, 177, 178], vec![514, 515, 512, 513]), Op::U8RangeCheck(516, 517), Op::U8RangeCheck(518, 519), Op::Mul(520, 520), Op::AssertEq(vec![521], vec![520], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(375, 516), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::Add(524, 527), Op::Add(526, 529), Op::Add(528, 523), Op::Add(522, 525), Op::UnconstrainedU32Add3(vec![503, 504, 505, 506], vec![530, 531, 532, 533], vec![116, 117, 118, 119]), Op::U8RangeCheck(534, 535), Op::U8RangeCheck(536, 537), Op::Sub(538, 133), Op::Sub(538, 135), Op::Mul(539, 540), Op::Mul(538, 541), Op::AssertEq(vec![542], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(514, 534), Op::U8Xor(515, 535), Op::U8Xor(512, 536), Op::U8Xor(513, 537), Op::UnconstrainedU32Add(vec![516, 517, 518, 519], vec![544, 545, 546, 543]), Op::U8RangeCheck(547, 548), Op::U8RangeCheck(549, 550), Op::Mul(551, 551), Op::AssertEq(vec![552], vec![551], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(530, 547), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::Add(553, 556), Op::Add(555, 558), Op::Add(557, 560), Op::Add(559, 554), Op::UnconstrainedU32Add3(vec![348, 349, 350, 351], vec![189, 190, 191, 192], vec![120, 121, 122, 123]), Op::U8RangeCheck(565, 566), Op::U8RangeCheck(567, 568), Op::Sub(569, 133), Op::Sub(569, 135), Op::Mul(570, 571), Op::Mul(569, 572), Op::AssertEq(vec![573], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(296, 565), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(295, 568), Op::UnconstrainedU32Add(vec![237, 238, 239, 240], vec![576, 577, 574, 575]), Op::U8RangeCheck(578, 579), Op::U8RangeCheck(580, 581), Op::Mul(582, 582), Op::AssertEq(vec![583], vec![582], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(189, 578), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::Add(586, 589), Op::Add(588, 591), Op::Add(590, 585), Op::Add(584, 587), Op::UnconstrainedU32Add3(vec![565, 566, 567, 568], vec![592, 593, 594, 595], vec![124, 125, 126, 127]), Op::U8RangeCheck(596, 597), Op::U8RangeCheck(598, 599), Op::Sub(600, 133), Op::Sub(600, 135), Op::Mul(601, 602), Op::Mul(600, 603), Op::AssertEq(vec![604], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(576, 596), Op::U8Xor(577, 597), Op::U8Xor(574, 598), Op::U8Xor(575, 599), Op::UnconstrainedU32Add(vec![578, 579, 580, 581], vec![606, 607, 608, 605]), Op::U8RangeCheck(609, 610), Op::U8RangeCheck(611, 612), Op::Mul(613, 613), Op::AssertEq(vec![614], vec![613], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(592, 609), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::Add(615, 618), Op::Add(617, 620), Op::Add(619, 622), Op::Add(621, 616)], ctrl: Ctrl::Return(0, vec![410, 411, 412, 413, 472, 473, 474, 475, 534, 535, 536, 537, 596, 597, 598, 599, 623, 624, 625, 626, 437, 438, 439, 440, 499, 500, 501, 502, 561, 562, 563, 564, 547, 548, 549, 550, 609, 610, 611, 612, 423, 424, 425, 426, 485, 486, 487, 488, 482, 483, 484, 481, 544, 545, 546, 543, 606, 607, 608, 605, 420, 421, 422, 419, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]) }, layout: FunctionLayout { input_size: 128, selectors: 1, auxiliaries: 369, lookups: 193 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_34() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(35, vec![121, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 106, 107, 108, 109, 110, 111, 106, 112, 113, 114, 115, 116, 117, 118, 119, 120, 96, 97, 98, 99, 100, 101, 102, 103, 104, 121, 121, 121, 105, 121, 121, 121, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], 32, false)], ctrl: Ctrl::Return(0, vec![122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153]) }, layout: FunctionLayout { input_size: 106, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_35() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(35, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_36() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(40, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(0, vec![20]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(40, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(1, vec![20]) }), (G::from_u64(2), Block { ops: vec![Op::Call(781, vec![9], 8, false), Op::Const(G::from_u64(2)), Op::Call(41, vec![9, 18], 1, false), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 28], 1, false), Op::Call(40, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 29], 1, false)], ctrl: Ctrl::Return(2, vec![30]) }), (G::from_u64(3), Block { ops: vec![Op::Call(781, vec![9], 8, false), Op::Const(G::from_u64(3)), Op::Call(41, vec![9, 18], 1, false), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 28], 1, false), Op::Call(40, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 29], 1, false)], ctrl: Ctrl::Return(3, vec![30]) }), (G::from_u64(4), Block { ops: vec![Op::Load(18, 17), Op::Const(G::from_u64(4)), Op::Call(36, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 18], 1, false), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 38], 1, false), Op::Call(40, vec![37, 9, 10, 11, 12, 13, 14, 15, 16, 39], 1, false)], ctrl: Ctrl::Return(4, vec![40]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(40, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(5, vec![20]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(40, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(6, vec![20]) }), (G::from_u64(7), Block { ops: vec![Op::Call(46, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Const(G::from_u64(7)), Op::Call(49, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(40, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 28], 1, false)], ctrl: Ctrl::Return(7, vec![29]) }), (G::from_u64(8), Block { ops: vec![Op::Call(47, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Const(G::from_u64(8)), Op::Call(50, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(40, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 28], 1, false)], ctrl: Ctrl::Return(8, vec![29]) }), (G::from_u64(9), Block { ops: vec![Op::Call(48, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Const(G::from_u64(9)), Op::Call(51, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(40, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 28], 1, false)], ctrl: Ctrl::Return(9, vec![29]) }), (G::from_u64(10), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 6), Op::Load(18, 7), Op::Load(18, 8)], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![73]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(11, vec![73]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(74, 73), Op::Add(1, 75), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(10)), Op::Call(36, vec![55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 18], 1, false), Op::Call(36, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 79], 1, false), Op::Call(36, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 80], 1, false), Op::Call(44, vec![3, 4, 5, 81], 1, false), Op::Call(40, vec![78, 76, 77, 77, 77, 77, 77, 77, 77, 82], 1, false)], ctrl: Ctrl::Return(12, vec![83]) })) }))) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(11)), Op::Call(40, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(13, vec![20]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 14, auxiliaries: 61, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_37() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(8, 11), Op::Call(37, vec![1, 2, 3, 4, 5, 6, 7, 10, 12, 9], 1, false), Op::Store(vec![10, 0, 13])], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_38() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![0, 1, 2, 3, 4, 5, 6, 7], 1, false), Op::Const(G::from_u64(128)), Op::U8LessThan(0, 10)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 0, 8])], ctrl: Ctrl::Return(0, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(128)), Op::Const(G::from_u64(1)), Op::Sub(9, 13), Op::Add(12, 14), Op::Const(G::from_u64(0)), Op::Call(37, vec![0, 1, 2, 3, 4, 5, 6, 7, 9, 8], 1, false), Op::Store(vec![16, 15, 17])], ctrl: Ctrl::Return(1, vec![18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(128)), Op::Const(G::from_u64(1)), Op::Sub(9, 13), Op::Add(12, 14), Op::Const(G::from_u64(0)), Op::Call(37, vec![0, 1, 2, 3, 4, 5, 6, 7, 9, 8], 1, false), Op::Store(vec![16, 15, 17])], ctrl: Ctrl::Return(2, vec![18]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_39() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(32)), Op::U8LessThan(1, 11)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(0, 13), Op::Add(14, 1), Op::Const(G::from_u64(0)), Op::Store(vec![16, 15, 9])], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(0, 13), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(1)), Op::Sub(10, 16), Op::Add(15, 17), Op::Add(14, 18), Op::Const(G::from_u64(0)), Op::Call(37, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 9], 1, false), Op::Store(vec![20, 19, 21])], ctrl: Ctrl::Return(1, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(0, 13), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(1)), Op::Sub(10, 16), Op::Add(15, 17), Op::Add(14, 18), Op::Const(G::from_u64(0)), Op::Call(37, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 9], 1, false), Op::Store(vec![20, 19, 21])], ctrl: Ctrl::Return(2, vec![22]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_40() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(8)), Op::U8LessThan(1, 11)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(16)), Op::Mul(0, 13), Op::Add(14, 1), Op::Const(G::from_u64(0)), Op::Store(vec![16, 15, 9])], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(16)), Op::Mul(0, 13), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Sub(10, 16), Op::Add(15, 17), Op::Add(14, 18), Op::Const(G::from_u64(0)), Op::Call(37, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 9], 1, false), Op::Store(vec![20, 19, 21])], ctrl: Ctrl::Return(1, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(16)), Op::Mul(0, 13), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Sub(10, 16), Op::Add(15, 17), Op::Add(14, 18), Op::Const(G::from_u64(0)), Op::Call(37, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 9], 1, false), Op::Store(vec![20, 19, 21])], ctrl: Ctrl::Return(2, vec![22]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_41() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(41, vec![11, 1], 1, false), Op::Call(38, vec![3, 4, 5, 6, 7, 8, 9, 10, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_42() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![2]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![3]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(4, 3), Op::Add(2, 5)], ctrl: Ctrl::Return(4, vec![6]) })) })) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_43() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(2, vec![3]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Yield(3, vec![3]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(42, vec![1, 2], 1, false), Op::Mul(4, 5), Op::Add(3, 6)], ctrl: Ctrl::Return(4, vec![7]) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_44() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(43, vec![0, 1, 2], 1, false), Op::Store(vec![4, 5, 3])], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_45() -> Function { + Function { body: Block { ops: vec![Op::Call(43, vec![0, 1, 2], 1, false), Op::Const(G::from_u64(16)), Op::Call(42, vec![3, 4], 1, false), Op::Mul(7, 8), Op::Add(6, 9), Op::Const(G::from_u64(0)), Op::Store(vec![11, 10, 5])], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_46() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Load(18, 1), Op::Call(46, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(17, vec![36, 37, 38, 39, 40, 41, 42, 43], 8, false)], ctrl: Ctrl::Return(0, vec![44, 45, 46, 47, 48, 49, 50, 51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18, 18, 18, 18, 18, 18, 18, 18]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_47() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Load(18, 5), Op::Call(47, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(17, vec![36, 37, 38, 39, 40, 41, 42, 43], 8, false)], ctrl: Ctrl::Return(0, vec![44, 45, 46, 47, 48, 49, 50, 51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18, 18, 18, 18, 18, 18, 18, 18]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_48() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(9), Block { ops: vec![Op::Load(18, 7), Op::Call(48, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(17, vec![36, 37, 38, 39, 40, 41, 42, 43], 8, false)], ctrl: Ctrl::Return(0, vec![44, 45, 46, 47, 48, 49, 50, 51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18, 18, 18, 18, 18, 18, 18, 18]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_49() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Load(18, 1), Op::Load(18, 2), Op::Call(36, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(49, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false)], ctrl: Ctrl::Return(0, vec![56]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 39, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_50() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Load(18, 4), Op::Load(18, 5), Op::Call(50, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(36, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false), Op::Call(44, vec![1, 2, 3, 56], 1, false)], ctrl: Ctrl::Return(0, vec![57]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_51() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(9), Block { ops: vec![Op::Load(18, 6), Op::Load(18, 7), Op::Call(51, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(36, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false), Op::Call(45, vec![1, 2, 3, 4, 5, 56], 1, false)], ctrl: Ctrl::Return(0, vec![57]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_52() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(0)), Op::Store(vec![34, 33, 1]), Op::Store(vec![34, 32, 35]), Op::Store(vec![34, 31, 36]), Op::Store(vec![34, 30, 37]), Op::Store(vec![34, 29, 38]), Op::Store(vec![34, 28, 39]), Op::Store(vec![34, 27, 40]), Op::Store(vec![34, 26, 41]), Op::Store(vec![34, 25, 42]), Op::Store(vec![34, 24, 43]), Op::Store(vec![34, 23, 44]), Op::Store(vec![34, 22, 45]), Op::Store(vec![34, 21, 46]), Op::Store(vec![34, 20, 47]), Op::Store(vec![34, 19, 48]), Op::Store(vec![34, 18, 49]), Op::Store(vec![34, 17, 50]), Op::Store(vec![34, 16, 51]), Op::Store(vec![34, 15, 52]), Op::Store(vec![34, 14, 53]), Op::Store(vec![34, 13, 54]), Op::Store(vec![34, 12, 55]), Op::Store(vec![34, 11, 56]), Op::Store(vec![34, 10, 57]), Op::Store(vec![34, 9, 58]), Op::Store(vec![34, 8, 59]), Op::Store(vec![34, 7, 60]), Op::Store(vec![34, 6, 61]), Op::Store(vec![34, 5, 62]), Op::Store(vec![34, 4, 63]), Op::Store(vec![34, 3, 64]), Op::Store(vec![34, 2, 65])], ctrl: Ctrl::Return(0, vec![66]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 65, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_53() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![2]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(3, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(4, vec![2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(5, vec![2]) })].into_iter().collect(), None) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(6, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(9))], ctrl: Ctrl::Return(7, vec![2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(10))], ctrl: Ctrl::Return(8, vec![2]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_54() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Load(9, 1), Op::Call(54, vec![9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Call(17, vec![18, 19, 20, 21, 22, 23, 24, 25], 8, false)], ctrl: Ctrl::Return(0, vec![26, 27, 28, 29, 30, 31, 32, 33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9, 9, 9, 9, 9, 9, 9, 9]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 26, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_55() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Load(9, 1), Op::Call(55, vec![9, 10, 11, 12, 13, 14, 15, 16, 17], 9, false)], ctrl: Ctrl::Return(0, vec![18, 19, 20, 21, 22, 23, 24, 25, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 1, 2, 3, 4, 5, 6, 7, 8]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 19, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_56() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 9])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(54, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(55, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 9, false), Op::Const(G::from_u64(0)), Op::Call(56, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 9], 1, false), Op::Call(39, vec![27, 10, 11, 12, 13, 14, 15, 16, 17, 28], 1, false)], ctrl: Ctrl::Return(1, vec![29]) }), (G::from_u64(2), Block { ops: vec![Op::Load(9, 1), Op::Load(9, 2), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(56, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(56, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 30], 1, false), Op::Call(39, vec![28, 29, 29, 29, 29, 29, 29, 29, 29, 31], 1, false)], ctrl: Ctrl::Return(2, vec![32]) }), (G::from_u64(3), Block { ops: vec![Op::Load(9, 1), Op::Load(9, 2), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(56, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(56, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 30], 1, false), Op::Call(39, vec![28, 29, 29, 29, 29, 29, 29, 29, 29, 31], 1, false)], ctrl: Ctrl::Return(3, vec![32]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(39, vec![10, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 5, auxiliaries: 22, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_57() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(18, 3), Op::Call(57, vec![4, 1], 1, false), Op::Call(36, vec![5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 24, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_58() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(9, 3), Op::Call(58, vec![4, 1], 1, false), Op::Call(56, vec![5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![15]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_59() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(59, vec![4, 1], 1, false), Op::Call(52, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_60() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 1])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 1])], ctrl: Ctrl::Return(1, vec![4]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![2, 3, 1])], ctrl: Ctrl::Return(2, vec![4]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Store(vec![2, 3, 1])], ctrl: Ctrl::Return(3, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_61() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 10), Op::Load(18, 11), Op::Call(53, vec![0, 1], 1, false), Op::Const(G::from_u64(0)), Op::Call(36, vec![31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 12], 1, false), Op::Call(36, vec![13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 51], 1, false), Op::Call(38, vec![2, 3, 4, 5, 6, 7, 8, 9, 52], 1, false), Op::Store(vec![50, 49, 53])], ctrl: Ctrl::Return(0, vec![54]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 42, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_62() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 8), Op::Call(36, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(38, vec![0, 1, 2, 3, 4, 5, 6, 7, 28], 1, false)], ctrl: Ctrl::Return(0, vec![29]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 21, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_63() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(63, vec![12, 1], 1, false), Op::Call(62, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_64() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 42), Op::Const(G::from_u64(2)), Op::Mul(63, 1), Op::Add(0, 64), Op::Call(793, vec![43], 8, false), Op::Const(G::from_u64(0)), Op::Call(63, vec![43, 44], 1, false), Op::Call(38, vec![66, 67, 68, 69, 70, 71, 72, 73, 75], 1, false), Op::Call(36, vec![45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 76], 1, false), Op::Call(38, vec![34, 35, 36, 37, 38, 39, 40, 41, 77], 1, false), Op::Call(38, vec![26, 27, 28, 29, 30, 31, 32, 33, 78], 1, false), Op::Call(38, vec![18, 19, 20, 21, 22, 23, 24, 25, 79], 1, false), Op::Call(38, vec![10, 11, 12, 13, 14, 15, 16, 17, 80], 1, false), Op::Call(38, vec![2, 3, 4, 5, 6, 7, 8, 9, 81], 1, false), Op::Store(vec![74, 65, 82])], ctrl: Ctrl::Return(0, vec![83]) }))) }, layout: FunctionLayout { input_size: 45, selectors: 1, auxiliaries: 36, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_65() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 9), Op::Const(G::from_u64(0)), Op::Call(36, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 10], 1, false), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 30], 1, false), Op::Store(vec![29, 0, 31])], ctrl: Ctrl::Return(0, vec![32]) }))) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_66() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 9), Op::Call(36, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 10], 1, false), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 29], 1, false), Op::Call(60, vec![0, 30], 1, false)], ctrl: Ctrl::Return(0, vec![31]) }))) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_67() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 33), Op::Const(G::from_u64(0)), Op::Call(36, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 34], 1, false), Op::Call(38, vec![25, 26, 27, 28, 29, 30, 31, 32, 54], 1, false), Op::Call(38, vec![17, 18, 19, 20, 21, 22, 23, 24, 55], 1, false), Op::Call(38, vec![9, 10, 11, 12, 13, 14, 15, 16, 56], 1, false), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 57], 1, false), Op::Store(vec![53, 0, 58])], ctrl: Ctrl::Return(0, vec![59]) }))) }, layout: FunctionLayout { input_size: 35, selectors: 1, auxiliaries: 25, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_68() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(68, vec![37, 1], 1, false), Op::Call(67, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38], 1, false)], ctrl: Ctrl::Return(1, vec![39]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 39, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_69() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 25), Op::Call(788, vec![26], 8, false), Op::Const(G::from_u64(0)), Op::Call(68, vec![26, 27], 1, false), Op::Call(38, vec![46, 47, 48, 49, 50, 51, 52, 53, 55], 1, false), Op::Call(36, vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 56], 1, false), Op::Call(38, vec![17, 18, 19, 20, 21, 22, 23, 24, 57], 1, false), Op::Call(38, vec![9, 10, 11, 12, 13, 14, 15, 16, 58], 1, false), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 59], 1, false), Op::Store(vec![54, 0, 60])], ctrl: Ctrl::Return(0, vec![61]) }))) }, layout: FunctionLayout { input_size: 28, selectors: 1, auxiliaries: 34, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_70() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(52, vec![8, 9], 1, false), Op::Call(38, vec![0, 1, 2, 3, 4, 5, 6, 7, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_71() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(52, vec![16, 17], 1, false), Op::Call(38, vec![8, 9, 10, 11, 12, 13, 14, 15, 18], 1, false), Op::Call(38, vec![0, 1, 2, 3, 4, 5, 6, 7, 19], 1, false)], ctrl: Ctrl::Return(0, vec![20]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_72() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(61, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 45], 1, false), Op::Store(vec![46, 46, 47])], ctrl: Ctrl::Return(0, vec![48]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Call(69, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 45], 1, false), Op::Store(vec![46, 47, 48])], ctrl: Ctrl::Return(1, vec![49]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Call(64, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45], 1, false), Op::Store(vec![46, 47, 48])], ctrl: Ctrl::Return(2, vec![49]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 46, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_73() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(73, vec![48, 1], 1, false), Op::Call(72, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49], 1, false)], ctrl: Ctrl::Return(1, vec![50]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_74() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(61, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 45], 1, false)], ctrl: Ctrl::Return(0, vec![46]) }), (G::from_u64(1), Block { ops: vec![Op::Call(64, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45], 1, false)], ctrl: Ctrl::Return(1, vec![46]) }), (G::from_u64(2), Block { ops: vec![Op::Call(65, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 45], 1, false)], ctrl: Ctrl::Return(2, vec![46]) }), (G::from_u64(3), Block { ops: vec![Op::Call(66, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 45], 1, false)], ctrl: Ctrl::Return(3, vec![46]) }), (G::from_u64(4), Block { ops: vec![Op::Call(71, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 45], 1, false)], ctrl: Ctrl::Return(4, vec![46]) }), (G::from_u64(5), Block { ops: vec![Op::Call(70, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 45], 1, false)], ctrl: Ctrl::Return(5, vec![46]) }), (G::from_u64(6), Block { ops: vec![Op::Call(70, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 45], 1, false)], ctrl: Ctrl::Return(6, vec![46]) }), (G::from_u64(7), Block { ops: vec![Op::Call(70, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 45], 1, false)], ctrl: Ctrl::Return(7, vec![46]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 46, selectors: 8, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_75() -> Function { + Function { body: Block { ops: vec![Op::Call(783, vec![0], 8, false), Op::Call(57, vec![0, 1], 1, false), Op::Call(38, vec![2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_76() -> Function { + Function { body: Block { ops: vec![Op::Call(783, vec![0], 8, false), Op::Call(59, vec![0, 1], 1, false), Op::Call(38, vec![2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_77() -> Function { + Function { body: Block { ops: vec![Op::Call(783, vec![0], 8, false), Op::Call(58, vec![0, 1], 1, false), Op::Call(38, vec![2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_78() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(77, vec![47, 48], 1, false), Op::Call(76, vec![46, 49], 1, false), Op::Call(75, vec![45, 50], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Call(792, vec![1], 8, false), Op::Const(G::from_u64(12)), Op::Call(73, vec![1, 51], 1, false), Op::Call(40, vec![60, 52, 53, 54, 55, 56, 57, 58, 59, 61], 1, false)], ctrl: Ctrl::Return(0, vec![62]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 53, 53, 53, 53, 53, 53, 53, 54], 1, false)], ctrl: Ctrl::Return(1, vec![55]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(2, vec![56]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(3, vec![56]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(4, vec![56]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(5, vec![56]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(6, vec![56]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(7, vec![56]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Call(74, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(40, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(8, vec![56]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 49, selectors: 9, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_79() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_80() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2, 2, 2, 2, 2, 2, 2, 2, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Call(80, vec![4, 6], 9, false)], ctrl: Ctrl::Return(1, vec![3, 7, 8, 9, 10, 11, 12, 13, 15]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_81() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::U8BitDecomposition(2), Op::Const(G::from_u64(2)), Op::Mul(12, 5), Op::Const(G::from_u64(4)), Op::Mul(14, 6), Op::Const(G::from_u64(8)), Op::Mul(16, 7), Op::Const(G::from_u64(16)), Op::Mul(18, 8), Op::Const(G::from_u64(32)), Op::Mul(20, 9), Op::Const(G::from_u64(64)), Op::Mul(22, 10), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(4, 28)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![29, 30, 30, 30, 30, 30, 30, 30, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(29, 30), Op::Const(G::from_u64(9)), Op::U8LessThan(31, 32), Op::AssertEq(vec![33], vec![30], Some("tag0: payload width exceeds 8 bytes".into())), Op::Call(80, vec![3, 31], 9, false), Op::Call(6, vec![34, 35, 36, 37, 38, 39, 40, 41], 1, false), Op::AssertEq(vec![43], vec![31], Some("nonminimal tag0 width".into()))], ctrl: Ctrl::MatchContinue(31, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(34, 44), Op::Const(G::from_u64(0)), Op::AssertEq(vec![45], vec![46], Some("nonminimal tag0 value".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![34, 35, 36, 37, 38, 39, 40, 41, 42]) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_82() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::U8BitDecomposition(2), Op::Const(G::from_u64(2)), Op::Mul(12, 11), Op::Add(10, 13), Op::Mul(12, 5), Op::Const(G::from_u64(4)), Op::Mul(16, 6), Op::Const(G::from_u64(8)), Op::Mul(18, 7), Op::Const(G::from_u64(16)), Op::Mul(20, 8), Op::Add(19, 21), Op::Add(17, 22), Op::Add(15, 23), Op::Add(4, 24)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![14, 25, 26, 26, 26, 26, 26, 26, 26, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(25, 26), Op::Const(G::from_u64(9)), Op::U8LessThan(27, 28), Op::AssertEq(vec![29], vec![26], Some("tag2: payload width exceeds 8 bytes".into())), Op::Call(80, vec![3, 27], 9, false), Op::Call(6, vec![30, 31, 32, 33, 34, 35, 36, 37], 1, false), Op::AssertEq(vec![39], vec![27], Some("nonminimal tag2 width".into()))], ctrl: Ctrl::MatchContinue(27, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(32)), Op::U8LessThan(30, 40), Op::Const(G::from_u64(0)), Op::AssertEq(vec![41], vec![42], Some("nonminimal tag2 value".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![14, 30, 31, 32, 33, 34, 35, 36, 37, 38]) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_83() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::U8BitDecomposition(2), Op::Const(G::from_u64(2)), Op::Mul(12, 9), Op::Const(G::from_u64(4)), Op::Mul(14, 10), Op::Const(G::from_u64(8)), Op::Mul(16, 11), Op::Add(15, 17), Op::Add(13, 18), Op::Add(8, 19), Op::Mul(12, 5), Op::Mul(14, 6), Op::Add(21, 22), Op::Add(4, 23)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![20, 24, 25, 25, 25, 25, 25, 25, 25, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(24, 25), Op::Call(80, vec![3, 26], 9, false), Op::Call(6, vec![27, 28, 29, 30, 31, 32, 33, 34], 1, false), Op::AssertEq(vec![36], vec![26], Some("nonminimal tag4 width".into()))], ctrl: Ctrl::MatchContinue(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(8)), Op::U8LessThan(27, 37), Op::Const(G::from_u64(0)), Op::AssertEq(vec![38], vec![39], Some("nonminimal tag4 value".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![20, 27, 28, 29, 30, 31, 32, 33, 34, 35]) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 24, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_84() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(84, vec![18, 19, 20, 21, 22, 23, 24, 25, 26], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![29, 10, 11, 12, 13, 14, 15, 16, 17, 27])], ctrl: Ctrl::Return(1, vec![30, 28]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 22, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_85() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(92, vec![1], 2, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 0, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14]), Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 8, false), Op::Call(85, vec![15, 12, 16, 17, 18, 19, 20, 21, 22, 23], 2, false)], ctrl: Ctrl::Return(1, vec![24, 25]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_86() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![2]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![3]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![2, 3]) })) })) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_87() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(4, 1), Op::Add(0, 5)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(2, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Yield(3, vec![7]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Call(86, vec![2, 3], 2, false)], ctrl: Ctrl::Return(4, vec![7, 8, 9]) })) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_88() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::U8BitDecomposition(1), Op::Add(9, 10), Op::Add(8, 11), Op::Add(7, 12), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], Some("reserved binder contract bits".into())), Op::Call(87, vec![3, 4, 5, 6], 3, false)], ctrl: Ctrl::Return(0, vec![15, 16, 17, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_89() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::U8BitDecomposition(1), Op::Add(9, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("reserved forall contract bits".into())), Op::Call(87, vec![3, 4, 5, 6], 3, false), Op::Call(86, vec![7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![13, 14, 15, 16, 17, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_90() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(92, vec![0], 2, false), Op::Load(18, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![30], vec![31], Some("non-canonical lambda telescope".into()))], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10, 11]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(88, vec![0], 4, false), Op::Call(92, vec![13], 2, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(90, vec![15, 16, 17, 18, 19, 20, 21, 22, 23], 2, false), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 10, 11, 12, 14, 24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27])], ctrl: Ctrl::Return(2, vec![28, 25]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 23, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_91() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(92, vec![0], 2, false), Op::Load(18, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![30], vec![31], Some("non-canonical forall telescope".into()))], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10, 11]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(89, vec![0], 6, false), Op::Call(92, vec![15], 2, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(91, vec![17, 18, 19, 20, 21, 22, 23, 24, 25], 2, false), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(0)), Op::Store(vec![28, 10, 11, 12, 13, 14, 16, 26, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29])], ctrl: Ctrl::Return(2, vec![30, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 23, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_92() -> Function { + Function { body: Block { ops: vec![Op::Call(83, vec![0], 10, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(0, vec![12, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![13, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(81, vec![10], 9, false), Op::Call(84, vec![19, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![22, 11, 12, 13, 14, 15, 16, 17, 18, 20, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(2, vec![24, 21]) }), (G::from_u64(3), Block { ops: vec![Op::Call(81, vec![10], 9, false), Op::Call(84, vec![19, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![22, 11, 12, 13, 14, 15, 16, 17, 18, 20, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(3, vec![24, 21]) }), (G::from_u64(4), Block { ops: vec![Op::Call(81, vec![10], 9, false), Op::Call(92, vec![19], 2, false), Op::Const(G::from_u64(4)), Op::Store(vec![22, 11, 12, 13, 14, 15, 16, 17, 18, 2, 3, 4, 5, 6, 7, 8, 9, 20])], ctrl: Ctrl::Return(4, vec![23, 21]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(5, vec![13, 10]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(6, vec![13, 10]) }), (G::from_u64(7), Block { ops: vec![Op::Call(7, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("App with zero arguments".into())), Op::Call(92, vec![10], 2, false), Op::Load(18, 13)], ctrl: Ctrl::Match(15, [(G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![33], vec![34], Some("non-canonical application telescope".into())), Op::Call(85, vec![13, 14, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(7, vec![35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(85, vec![13, 14, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(8, vec![33, 34]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(7, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("Lam with zero binders".into())), Op::Call(90, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(9, vec![13, 14]) }), (G::from_u64(9), Block { ops: vec![Op::Call(7, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("All with zero binders".into())), Op::Call(91, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(10, vec![13, 14]) }), (G::from_u64(10), Block { ops: vec![Op::Call(93, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(11, vec![11, 12]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(11)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(12, vec![13, 10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 35, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_93() -> Function { + Function { body: Block { ops: vec![Op::Add(7, 8), Op::Add(6, 9), Op::Add(5, 10), Op::Add(4, 11), Op::Add(3, 12), Op::Add(2, 13), Op::Const(G::from_u64(0)), Op::AssertEq(vec![14], vec![15], Some("oversized let flags".into())), Op::Const(G::from_u64(4)), Op::U8LessThan(1, 16), Op::Const(G::from_u64(1)), Op::AssertEq(vec![17], vec![18], Some("reserved let flags".into())), Op::U8BitDecomposition(1)], ctrl: Ctrl::MatchContinue(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![27]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![27]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Call(88, vec![0], 4, false), Op::Call(92, vec![31], 2, false), Op::Call(92, vec![33], 2, false), Op::Call(92, vec![35], 2, false), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(0)), Op::Store(vec![38, 19, 27, 28, 29, 30, 32, 34, 36, 39, 39, 39, 39, 39, 39, 39, 39, 39])], ctrl: Ctrl::Return(2, vec![40, 37]) })) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 22, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_94() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 2, 3, 4, 5, 6, 7, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(18, vec![9, 10, 11, 12, 13, 14, 15, 16], 8, false), Op::Call(94, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 18, 19, 20, 21, 22, 23, 24, 25], 9, false), Op::Const(G::from_u64(1)), Op::Store(vec![26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![35, 36, 37, 37, 37, 37, 37, 37, 37]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 17, selectors: 2, auxiliaries: 20, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_95() -> Function { + Function { body: Block { ops: vec![Op::Call(82, vec![0], 10, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(7, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(95, vec![10], 10, false), Op::Call(94, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 2, 3, 4, 5, 6, 7, 8, 9], 9, false)], ctrl: Ctrl::Return(1, vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 21]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Call(95, vec![10], 10, false), Op::Call(95, vec![20], 10, false), Op::Const(G::from_u64(2)), Op::Store(vec![11, 12, 13, 14, 15, 16, 17, 18, 19]), Op::Store(vec![21, 22, 23, 24, 25, 26, 27, 28, 29]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![31, 32, 33, 34, 34, 34, 34, 34, 34, 30]) }), (G::from_u64(2), Block { ops: vec![Op::Call(95, vec![10], 10, false), Op::Call(95, vec![20], 10, false), Op::Const(G::from_u64(3)), Op::Store(vec![11, 12, 13, 14, 15, 16, 17, 18, 19]), Op::Store(vec![21, 22, 23, 24, 25, 26, 27, 28, 29]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![31, 32, 33, 34, 34, 34, 34, 34, 34, 30]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(4, vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 33, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_96() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Store(vec![2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 86, 89, 92, 95])], ctrl: Ctrl::Return(0, vec![97, 96]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 98, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_97() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(92, vec![0], 2, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(97, vec![11, 12, 13, 14, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![22, 10, 20])], ctrl: Ctrl::Return(1, vec![23, 21]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_98() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(95, vec![0], 10, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(98, vec![19, 20, 21, 22, 23, 24, 25, 26, 27], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12, 13, 14, 15, 16, 17, 18]), Op::Store(vec![30, 31, 28])], ctrl: Ctrl::Return(1, vec![32, 29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_99() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(96, vec![0], 2, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(99, vec![11, 12, 13, 14, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![22, 10, 20])], ctrl: Ctrl::Return(1, vec![23, 21]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_100() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(97, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_101() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(99, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_102() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(98, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_103() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1, 1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1, 2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1, 2]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![1, 2]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1, 1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(5, vec![1, 2]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![1, 2]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1, 2]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(8, vec![1, 1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_104() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Call(103, vec![1], 2, false), Op::Call(81, vec![2], 9, false), Op::Call(92, vec![13], 2, false), Op::Call(92, vec![15], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 17]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_105() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(92, vec![9], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_106() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(92, vec![18], 2, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(106, vec![20, 21, 22, 23, 24, 25, 26, 27, 28], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![31, 10, 11, 12, 13, 14, 15, 16, 17, 19, 29])], ctrl: Ctrl::Return(1, vec![32, 30]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_107() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Const(G::from_u64(4)), Op::U8LessThan(1, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], Some("invalid recursor flags".into())), Op::U8BitDecomposition(1), Op::Call(81, vec![2], 9, false), Op::Call(81, vec![22], 9, false), Op::Call(81, vec![31], 9, false), Op::Call(81, vec![40], 9, false), Op::Call(81, vec![49], 9, false), Op::Call(92, vec![58], 2, false), Op::Call(81, vec![60], 9, false), Op::Call(106, vec![69, 61, 62, 63, 64, 65, 66, 67, 68], 2, false)], ctrl: Ctrl::Return(0, vec![6, 7, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 55, 56, 57, 59, 70, 71]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 70, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_108() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::U8LessThan(0, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![2], vec![3], Some("Bool byte is not 0 or 1".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_109() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Call(108, vec![1], 0, false), Op::Call(81, vec![2], 9, false), Op::Call(92, vec![11], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_110() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(3, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_111() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Call(110, vec![1], 1, false), Op::Call(81, vec![2], 9, false), Op::Call(92, vec![12], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_112() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Call(108, vec![1], 0, false), Op::Call(81, vec![2], 9, false), Op::Call(81, vec![11], 9, false), Op::Call(81, vec![20], 9, false), Op::Call(81, vec![29], 9, false), Op::Call(92, vec![38], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 35, 36, 37, 39, 40]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_113() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(112, vec![0], 35, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(113, vec![44, 45, 46, 47, 48, 49, 50, 51, 52], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![55, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 53])], ctrl: Ctrl::Return(1, vec![56, 54]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 48, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_114() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Call(108, vec![1], 0, false), Op::U8BitDecomposition(1), Op::Call(81, vec![2], 9, false), Op::Call(81, vec![19], 9, false), Op::Call(81, vec![28], 9, false), Op::Call(92, vec![37], 2, false), Op::Call(81, vec![39], 9, false), Op::Call(113, vec![48, 40, 41, 42, 43, 44, 45, 46, 47], 2, false)], ctrl: Ctrl::Return(0, vec![3, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 38, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_115() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(96, vec![9], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_116() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(81, vec![9], 9, false), Op::Call(96, vec![18], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_117() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(104, vec![2], 13, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![16, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 15]) }), (G::from_u64(1), Block { ops: vec![Op::Call(114, vec![2], 28, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![31, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 30]) }), (G::from_u64(2), Block { ops: vec![Op::Call(107, vec![2], 45, false), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![48, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 48, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_118() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(117, vec![0], 46, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(118, vec![55, 56, 57, 58, 59, 60, 61, 62, 63], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![66, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 64])], ctrl: Ctrl::Return(1, vec![67, 65]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 59, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_119() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(104, vec![1], 13, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 14]) }), (G::from_u64(1), Block { ops: vec![Op::Call(107, vec![1], 45, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![47, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46]) }), (G::from_u64(2), Block { ops: vec![Op::Call(109, vec![1], 11, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![13, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12]) }), (G::from_u64(3), Block { ops: vec![Op::Call(111, vec![1], 11, false), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![13, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12]) }), (G::from_u64(4), Block { ops: vec![Op::Call(116, vec![1], 18, false), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 19]) }), (G::from_u64(5), Block { ops: vec![Op::Call(115, vec![1], 10, false), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![12, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) }), (G::from_u64(6), Block { ops: vec![Op::Call(115, vec![1], 10, false), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![12, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) }), (G::from_u64(7), Block { ops: vec![Op::Call(115, vec![1], 10, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![12, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 8, auxiliaries: 46, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_120() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(12), Block { ops: vec![Op::Call(118, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) }), (G::from_u64(13), Block { ops: vec![Op::Add(2, 3), Op::Add(10, 4), Op::Add(11, 5), Op::Add(12, 6), Op::Add(13, 7), Op::Add(14, 8), Op::Const(G::from_u64(0)), Op::AssertEq(vec![15], vec![16], Some("constant info: tag4 size exceeds a single byte".into())), Op::Call(119, vec![1, 9], 46, false)], ctrl: Ctrl::Return(1, vec![17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 47, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_121() -> Function { + Function { body: Block { ops: vec![Op::Call(83, vec![0], 10, false)], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(12), Block { ops: vec![Op::Call(118, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![13, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12]) }), (G::from_u64(13), Block { ops: vec![Op::Add(3, 4), Op::Add(11, 5), Op::Add(12, 6), Op::Add(13, 7), Op::Add(14, 8), Op::Add(15, 9), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], Some("constant info: tag4 size exceeds a single byte".into())), Op::Call(119, vec![2, 10], 46, false)], ctrl: Ctrl::Yield(1, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63]) })].into_iter().collect(), None, 46, 46, 1, Box::new(Block { ops: vec![Op::Call(81, vec![56], 9, false), Op::Call(97, vec![65, 57, 58, 59, 60, 61, 62, 63, 64], 2, false), Op::Call(81, vec![67], 9, false), Op::Call(99, vec![76, 68, 69, 70, 71, 72, 73, 74, 75], 2, false), Op::Call(81, vec![78], 9, false), Op::Call(98, vec![87, 79, 80, 81, 82, 83, 84, 85, 86], 2, false)], ctrl: Ctrl::Return(2, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 66, 77, 88, 89]) })) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 136, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_122() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Call(122, vec![2], 2, false), Op::Call(780, vec![6, 3], 1, false)], ctrl: Ctrl::Return(0, vec![5, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![0, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_123() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12]), Op::Store(vec![11, 12, 11, 11, 11, 11, 11, 11, 11, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(16, vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 12, 12, 12, 12, 12, 12], 9, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![22, 13, 14, 15, 16, 17, 18, 19, 20, 10])], ctrl: Ctrl::Return(1, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(123, vec![10], 1, false), Op::Store(vec![22, 13, 14, 15, 16, 17, 18, 19, 20, 23])], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_124() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(123, vec![1], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(123, vec![0], 1, false)], ctrl: Ctrl::Return(3, vec![23]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(16, vec![4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 16, 17, 18, 19, 20, 21], 9, false), Op::Const(G::from_u64(0)), Op::Call(16, vec![23, 24, 25, 26, 27, 28, 29, 30, 2, 32, 32, 32, 32, 32, 32, 32], 9, false), Op::Add(31, 41), Op::Call(124, vec![12, 22, 42], 1, false), Op::Store(vec![32, 33, 34, 35, 36, 37, 38, 39, 40, 43])], ctrl: Ctrl::Return(4, vec![44]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 41, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_125() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(124, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_126() -> Function { + Function { body: Block { ops: vec![Op::U8Sub(0, 8), Op::U8Sub(1, 9), Op::U8Sub(18, 17), Op::Add(19, 21), Op::U8Sub(2, 10), Op::U8Sub(23, 22), Op::Add(24, 26), Op::U8Sub(3, 11), Op::U8Sub(28, 27), Op::Add(29, 31), Op::U8Sub(4, 12), Op::U8Sub(33, 32), Op::Add(34, 36), Op::U8Sub(5, 13), Op::U8Sub(38, 37), Op::Add(39, 41), Op::U8Sub(6, 14), Op::U8Sub(43, 42), Op::Add(44, 46), Op::U8Sub(7, 15), Op::U8Sub(48, 47), Op::Add(49, 51)], ctrl: Ctrl::Return(0, vec![16, 20, 25, 30, 35, 40, 45, 50, 52]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_127() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(0, vec![24, 2]) }), (G::from_u64(0), Block { ops: vec![Op::Call(141, vec![1], 1, false)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24, 24, 24, 24, 24, 24, 24, 24])], ctrl: Ctrl::Return(1, vec![25, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24, 24, 24, 24, 24, 24, 24, 24])], ctrl: Ctrl::Return(2, vec![25, 24]) }))) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![0, 23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(126, vec![4, 5, 6, 7, 8, 9, 10, 11, 23, 24, 24, 24, 24, 24, 24, 24], 9, false), Op::Store(vec![23, 23, 23, 23, 23, 23, 23, 23, 23, 23]), Op::Call(127, vec![12, 34, 33], 2, false), Op::Store(vec![24, 25, 26, 27, 28, 29, 30, 31, 32, 35])], ctrl: Ctrl::Return(4, vec![37, 36]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(126, vec![4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 16, 17, 18, 19, 20, 21], 9, false), Op::Const(G::from_u64(0)), Op::Call(126, vec![23, 24, 25, 26, 27, 28, 29, 30, 2, 32, 32, 32, 32, 32, 32, 32], 9, false), Op::Add(31, 41), Op::Call(127, vec![12, 22, 42], 2, false), Op::Store(vec![32, 33, 34, 35, 36, 37, 38, 39, 40, 43])], ctrl: Ctrl::Return(5, vec![45, 44]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 42, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_128() -> Function { + Function { body: Block { ops: vec![Op::Call(129, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_129() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 13]) }), (G::from_u64(0), Block { ops: vec![Op::U8RangeCheck(2, 3), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::Call(129, vec![10], 2, false), Op::Call(3, vec![12], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 2, 3, 4, 5, 6, 7, 8, 9, 11])], ctrl: Ctrl::Return(1, vec![15, 13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_130() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(130, vec![10], 1, false), Op::Load(10, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(7, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(1, vec![24]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24, 24, 24, 24, 24, 24, 24, 24]), Op::Store(vec![23, 2, 3, 4, 5, 6, 7, 8, 9, 25])], ctrl: Ctrl::Return(2, vec![26]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![22, 2, 3, 4, 5, 6, 7, 8, 9, 11])], ctrl: Ctrl::Return(3, vec![23]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_131() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(127, vec![0, 1, 2], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(130, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_132() -> Function { + Function { body: Block { ops: vec![Op::Call(131, vec![0, 1], 1, false), Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_133() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![1, 2, 1, 1, 1, 1, 1, 1, 1, 3]), Op::Call(131, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_134() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::U32LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Sub(0, 4), Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(134, vec![5, 7], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_135() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 1), Op::Add(0, 17), Op::Mul(16, 9), Op::Add(8, 19), Op::Mul(16, 3), Op::Add(2, 21), Op::Mul(16, 11), Op::Add(10, 23), Op::Mul(16, 5), Op::Add(4, 25), Op::Mul(16, 13), Op::Add(12, 27), Op::Mul(16, 7), Op::Add(6, 29), Op::Mul(16, 15), Op::Add(14, 31), Op::Mul(18, 20), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(34, 35), Op::U8RangeCheck(36, 37), Op::Const(G::from_u64(0)), Op::U8RangeCheck(38, 42), Op::Mul(16, 35), Op::Const(G::from_u64(65536)), Op::Mul(16, 37), Op::Mul(44, 38), Op::Add(45, 46), Op::Add(36, 47), Op::Mul(44, 48), Op::Add(43, 49), Op::Add(34, 50), Op::AssertEq(vec![33], vec![51], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 24), Op::Mul(22, 20), Op::Add(53, 48), Op::Add(52, 54), Op::UnconstrainedGToBytes(55), Op::U8RangeCheck(56, 57), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 42), Op::Mul(16, 57), Op::Mul(16, 59), Op::Mul(44, 60), Op::Add(65, 66), Op::Add(58, 67), Op::Mul(44, 68), Op::Add(64, 69), Op::Add(56, 70), Op::AssertEq(vec![55], vec![71], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 28), Op::Mul(22, 24), Op::Mul(26, 20), Op::Add(74, 68), Op::Add(73, 75), Op::Add(72, 76), Op::UnconstrainedGToBytes(77), Op::U8RangeCheck(78, 79), Op::U8RangeCheck(80, 81), Op::U8RangeCheck(82, 42), Op::Mul(16, 79), Op::Mul(16, 81), Op::Mul(44, 82), Op::Add(87, 88), Op::Add(80, 89), Op::Mul(44, 90), Op::Add(86, 91), Op::Add(78, 92), Op::AssertEq(vec![77], vec![93], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 32), Op::Mul(22, 28), Op::Mul(26, 24), Op::Mul(30, 20), Op::Add(97, 90), Op::Add(96, 98), Op::Add(95, 99), Op::Add(94, 100), Op::UnconstrainedGToBytes(101), Op::U8RangeCheck(102, 103), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 42), Op::Mul(16, 103), Op::Mul(16, 105), Op::Mul(44, 106), Op::Add(111, 112), Op::Add(104, 113), Op::Mul(44, 114), Op::Add(110, 115), Op::Add(102, 116), Op::AssertEq(vec![101], vec![117], Some("u64_mul: column hint does not recompose".into())), Op::Mul(22, 32), Op::Mul(26, 28), Op::Mul(30, 24), Op::Add(120, 114), Op::Add(119, 121), Op::Add(118, 122), Op::UnconstrainedGToBytes(123), Op::U8RangeCheck(124, 125), Op::U8RangeCheck(126, 127), Op::U8RangeCheck(128, 42), Op::Mul(16, 125), Op::Mul(16, 127), Op::Mul(44, 128), Op::Add(133, 134), Op::Add(126, 135), Op::Mul(44, 136), Op::Add(132, 137), Op::Add(124, 138), Op::AssertEq(vec![123], vec![139], Some("u64_mul: column hint does not recompose".into())), Op::Mul(26, 32), Op::Mul(30, 28), Op::Add(141, 136), Op::Add(140, 142), Op::UnconstrainedGToBytes(143), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::U8RangeCheck(148, 42), Op::Mul(16, 145), Op::Mul(16, 147), Op::Mul(44, 148), Op::Add(153, 154), Op::Add(146, 155), Op::Mul(44, 156), Op::Add(152, 157), Op::Add(144, 158), Op::AssertEq(vec![143], vec![159], Some("u64_mul: column hint does not recompose".into())), Op::Mul(30, 32), Op::Add(160, 156), Op::UnconstrainedGToBytes(161), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::U8RangeCheck(166, 42), Op::Mul(16, 163), Op::Mul(16, 165), Op::Mul(44, 166), Op::Add(171, 172), Op::Add(164, 173), Op::Mul(44, 174), Op::Add(170, 175), Op::Add(162, 176), Op::AssertEq(vec![161], vec![177], Some("u64_mul: column hint does not recompose".into())), Op::AssertEq(vec![166], vec![42], Some("u64_mul: final carry exceeds one radix digit".into()))], ctrl: Ctrl::Return(0, vec![34, 35, 56, 57, 78, 79, 102, 103, 124, 125, 144, 145, 162, 163, 164, 165]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_136() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::Const(G::from_u64(0)), Op::U8RangeCheck(5, 9), Op::Const(G::from_u64(256)), Op::Mul(10, 2), Op::Const(G::from_u64(65536)), Op::Mul(10, 4), Op::Mul(12, 5), Op::Add(13, 14), Op::Add(3, 15), Op::Mul(12, 16), Op::Add(11, 17), Op::Add(1, 18), Op::AssertEq(vec![0], vec![19], Some("u64_mul: column hint does not recompose".into()))], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_137() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Const(G::from_u64(0)), Op::Call(138, vec![0, 1, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_138() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(139, vec![5, 6, 7, 8, 9, 10, 11, 12, 1, 14, 14, 14, 14, 14, 14, 14, 14], 1, false), Op::Call(140, vec![15, 3], 1, false), Op::Call(125, vec![2, 16], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 18), Op::Call(138, vec![13, 1, 17, 19], 1, false)], ctrl: Ctrl::Return(1, vec![20]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_139() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 8)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Call(7, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false)], ctrl: Ctrl::Match(27, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28])], ctrl: Ctrl::Return(0, vec![29]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29, 29, 29, 29, 29, 29, 29, 29]), Op::Store(vec![28, 9, 10, 11, 12, 13, 14, 15, 16, 30])], ctrl: Ctrl::Return(1, vec![31]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Call(135, vec![0, 1, 2, 3, 4, 5, 6, 7, 18, 19, 20, 21, 22, 23, 24, 25], 16, false), Op::Call(16, vec![27, 28, 29, 30, 31, 32, 33, 34, 9, 10, 11, 12, 13, 14, 15, 16], 9, false)], ctrl: Ctrl::Match(51, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(139, vec![0, 1, 2, 3, 4, 5, 6, 7, 26, 35, 36, 37, 38, 39, 40, 41, 42], 1, false), Op::Store(vec![52, 43, 44, 45, 46, 47, 48, 49, 50, 53])], ctrl: Ctrl::Return(2, vec![54]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(17, vec![35, 36, 37, 38, 39, 40, 41, 42], 8, false), Op::Call(139, vec![0, 1, 2, 3, 4, 5, 6, 7, 26, 53, 54, 55, 56, 57, 58, 59, 60], 1, false), Op::Store(vec![52, 43, 44, 45, 46, 47, 48, 49, 50, 61])], ctrl: Ctrl::Return(3, vec![62]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 17, selectors: 4, auxiliaries: 47, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_140() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(140, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_141() -> Function { + Function { body: Block { ops: vec![Op::Call(130, vec![0], 1, false), Op::Load(10, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_142() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedBigUintDivMod(0, 1), Op::Call(128, vec![2], 1, false), Op::Call(130, vec![4], 1, false), Op::Call(128, vec![3], 1, false), Op::Call(130, vec![6], 1, false), Op::Call(137, vec![5, 1], 1, false), Op::Call(125, vec![8, 7], 1, false), Op::Call(130, vec![9], 1, false), Op::Call(130, vec![0], 1, false), Op::AssertEq(vec![10], vec![11], Some("div/mod hint: q*b + r != a".into())), Op::Call(141, vec![1], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(141, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("div/mod hint: division by zero must yield a zero quotient".into()))], ctrl: Ctrl::Return(0, vec![5, 7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(123, vec![7], 1, false), Op::Call(132, vec![13, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], Some("div/mod hint: remainder is not less than the divisor".into()))], ctrl: Ctrl::Return(1, vec![5, 7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_143() -> Function { + Function { body: Block { ops: vec![Op::Call(142, vec![0, 1], 2, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_144() -> Function { + Function { body: Block { ops: vec![Op::Call(142, vec![0, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_145() -> Function { + Function { body: Block { ops: vec![Op::Call(141, vec![1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(144, vec![0, 1], 1, false), Op::Call(145, vec![1, 3], 1, false)], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_146() -> Function { + Function { body: Block { ops: vec![Op::Call(141, vec![1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4, 4, 4, 4]), Op::Store(vec![3, 4, 3, 3, 3, 3, 3, 3, 3, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]), Op::Store(vec![3, 4, 3, 3, 3, 3, 3, 3, 3, 6]), Op::Call(142, vec![1, 7], 2, false), Op::Call(137, vec![0, 0], 1, false), Op::Call(130, vec![10], 1, false), Op::Call(130, vec![8], 1, false), Op::Call(146, vec![11, 12], 1, false), Op::Call(141, vec![9], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Call(137, vec![0, 13], 1, false)], ctrl: Ctrl::Return(2, vec![15]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 12, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_147() -> Function { + Function { body: Block { ops: vec![Op::U8And(0, 8), Op::U8And(1, 9), Op::U8And(2, 10), Op::U8And(3, 11), Op::U8And(4, 12), Op::U8And(5, 13), Op::U8And(6, 14), Op::U8And(7, 15)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_148() -> Function { + Function { body: Block { ops: vec![Op::U8Or(0, 8), Op::U8Or(1, 9), Op::U8Or(2, 10), Op::U8Or(3, 11), Op::U8Or(4, 12), Op::U8Or(5, 13), Op::U8Or(6, 14), Op::U8Or(7, 15)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_149() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 8), Op::U8Xor(1, 9), Op::U8Xor(2, 10), Op::U8Xor(3, 11), Op::U8Xor(4, 12), Op::U8Xor(5, 13), Op::U8Xor(6, 14), Op::U8Xor(7, 15)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_150() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22])], ctrl: Ctrl::Return(1, vec![23]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(147, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(150, vec![11, 21], 1, false), Op::Store(vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(2, vec![32]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_151() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(148, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(151, vec![11, 21], 1, false), Op::Store(vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(2, vec![32]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_152() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(149, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(152, vec![11, 21], 1, false), Op::Store(vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(2, vec![32]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_153() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4, 4, 4, 4]), Op::Store(vec![2, 3, 2, 2, 2, 2, 2, 2, 2, 5]), Op::Call(146, vec![6, 1], 1, false), Op::Call(137, vec![0, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_154() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4, 4, 4, 4]), Op::Store(vec![2, 3, 2, 2, 2, 2, 2, 2, 2, 5]), Op::Call(146, vec![6, 1], 1, false), Op::Call(143, vec![0, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_155() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(238)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(70)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 2, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 4, 15, 17, 18, 19, 20, 21, 22, 23, 2, 20, 24, 25])], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_156() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(66)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(166)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 9, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 4, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_157() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(118)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(207)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_158() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(10)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(47)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 2, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 6, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_159() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(247)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(204)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 18, 16, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_160() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(157)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(52)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(13)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 3, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_161() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(133)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(234)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 11, 12, 13, 14, 4, 15, 16, 4, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_162() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(176)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(234)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_163() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(126)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 19, 22, 23, 24, 25, 13, 26, 7, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_164() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(226)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(231)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 2, 16, 17, 18, 19, 20, 3, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_165() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(156)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(84)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 4, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_166() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(11)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(179)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 10, 21, 5, 22, 23, 24, 17, 25, 26, 18, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_167() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(109)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(125)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 8, 16, 17, 18, 19, 20, 19, 21, 22, 23, 24, 25, 26, 7, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_168() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(38)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(8)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_169() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(135)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(164)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 7, 11, 12, 13, 14, 15, 16, 17, 18, 19, 17, 20, 21, 22, 23, 13, 16, 24, 25, 26, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_170() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(114)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(172)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 10, 22, 23, 24, 25, 26, 27, 28, 5, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_171() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(157)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(38)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 21, 22, 23, 3, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_172() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(86)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(212)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 11, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_173() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(91)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(21)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 9, 10, 11, 12, 10, 13, 14, 3, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_174() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(118)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(21)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 20, 22, 23, 24, 25, 19, 26, 27, 3])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_175() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(230)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(249)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 22, 25, 13, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_176() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(192)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(25)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 12, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_177() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(198)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(93)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 0, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 10, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_178() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(203)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(232)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_179() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(216)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(232)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 9, 24, 25, 26, 27, 11, 28, 1])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_180() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(92)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(12)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 4, 17, 18, 19, 20, 21, 22, 23, 0, 24, 25, 26, 11, 10, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_181() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(63)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(173)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_182() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(197)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 20, 24, 25, 26, 13, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_183() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(104)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(101)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3, 8, 18, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_184() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(162)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(98)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 5, 23, 2, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_185() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(221)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(62)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_186() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(111)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(24)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 8, 18, 19, 20, 21, 22, 14, 23, 24, 25, 26, 24, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_187() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(232)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(112)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 2, 23, 24, 11, 25, 26, 27, 28, 4])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_188() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(186)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(48)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 11, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 4, 25, 26, 15, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_189() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(182)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(149)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 1, 18, 2, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_190() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(234)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(48)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 18, 21, 22, 23, 6, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_191() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(187)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 15, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_192() -> Function { + Function { body: Block { ops: vec![Op::Call(186, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(187, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(188, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(189, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(190, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![11]) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 16, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_193() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![0, 1, 0, 0, 0, 0, 0, 0, 0, 3]), Op::Const(G::from_u64(7)), Op::Store(vec![5, 0, 4, 0])], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_194() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), Op::Store(vec![0, 1, 0, 0, 0, 0, 0, 0, 0, 2]), Op::Const(G::from_u64(7)), Op::Store(vec![4, 0, 3, 0])], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_195() -> Function { + Function { body: Block { ops: vec![Op::Call(186, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(193, vec![], 1, false)], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(187, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(194, vec![], 1, false)], ctrl: Ctrl::Return(1, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(190, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(196, vec![1], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(188, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false), Op::Call(189, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false), Op::Add(10, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(3, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(14, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(4, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 17], 1, false), Op::Call(425, vec![18, 2], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(197, vec![19], 2, false)], ctrl: Ctrl::Return(5, vec![20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(198, vec![19], 2, false)], ctrl: Ctrl::Return(6, vec![20, 21]) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 28, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_196() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(3)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(789, vec![0, 4], 1, false), Op::Call(122, vec![5], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(191, vec![], 1, false), Op::Call(2, vec![9, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(193, vec![], 1, false)], ctrl: Ctrl::Return(1, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(2, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(3, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 20, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_197() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![Op::Call(184, vec![], 1, false), Op::Call(2, vec![2, 5], 1, false), Op::Call(185, vec![], 1, false), Op::Call(2, vec![2, 7], 1, false), Op::Add(6, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(2, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_198() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(1, vec![5, 6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(2, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_199() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(193)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(221)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 12, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_200() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(41)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(153)), Op::Store(vec![0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 7])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_201() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(127)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(52)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(37)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_202() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(147)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(124)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 23, 24, 8, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_203() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(32)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(153)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 10, 22, 3, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_204() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(72)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(97)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 17, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_205() -> Function { + Function { body: Block { ops: vec![Op::Call(199, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(202, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(203, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_206() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(185, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Const(G::from_u64(0)), Op::Store(vec![1, 2, 4, 5])], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(184, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Const(G::from_u64(0)), Op::Store(vec![1, 2, 4, 5])], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_207() -> Function { + Function { body: Block { ops: vec![Op::Call(210, vec![1], 3, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![5, 7]) }), (G::from_u64(1), Block { ops: vec![Op::Call(251, vec![4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8])], ctrl: Ctrl::Return(1, vec![7, 9]) }), (G::from_u64(1), Block { ops: vec![Op::Call(251, vec![3], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(2, vec![9, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11]), Op::Store(vec![9, 10, 9, 9, 9, 9, 9, 9, 9, 12]), Op::Call(146, vec![13, 8], 1, false), Op::Call(144, vec![6, 14], 1, false), Op::Call(130, vec![15], 1, false)], ctrl: Ctrl::Return(3, vec![11, 16]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 13, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_208() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(3)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![0, 6], 1, false), Op::Const(G::from_u64(2)), Op::Call(789, vec![0, 8], 1, false), Op::Call(207, vec![5, 7], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13]) }), (G::from_u64(1), Block { ops: vec![Op::Call(207, vec![5, 9], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(2, vec![14, 15]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(132, vec![13, 11], 1, false), Op::Sub(14, 15), Op::Call(206, vec![16], 1, false)], ctrl: Ctrl::Return(3, vec![14, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 18, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_209() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![0, 4], 1, false), Op::Call(122, vec![5], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(204, vec![], 1, false), Op::Call(2, vec![9, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(1, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![7], 1, false), Op::Const(G::from_u64(4)), Op::U32LessThan(14, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(2, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![7, 17], 1, false), Op::Call(122, vec![18], 2, false), Op::Load(4, 19)], ctrl: Ctrl::Match(21, [(G::from_u64(2), Block { ops: vec![Op::Call(201, vec![], 1, false), Op::Call(2, vec![22, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![27, 27, 27, 27])], ctrl: Ctrl::Return(3, vec![27, 28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![20], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(27, 28)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![30, 30, 30, 30])], ctrl: Ctrl::Return(4, vec![30, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![20, 30], 1, false), Op::Const(G::from_u64(2)), Op::Call(789, vec![7, 32], 1, false), Op::Const(G::from_u64(3)), Op::Call(789, vec![7, 34], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Store(vec![30, 35, 37]), Op::Store(vec![30, 33, 38]), Op::Store(vec![30, 31, 39]), Op::Call(208, vec![40], 2, false)], ctrl: Ctrl::Return(5, vec![41, 42]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![25, 25, 25, 25])], ctrl: Ctrl::Return(6, vec![25, 26]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(7, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 8, auxiliaries: 54, lookups: 40 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_210() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(200, vec![], 1, false), Op::Call(2, vec![4, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![2], 1, false), Op::Const(G::from_u64(2)), Op::Sub(9, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(789, vec![2, 13], 1, false), Op::Call(789, vec![2, 12], 1, false)], ctrl: Ctrl::Return(0, vec![12, 14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(2, vec![9, 10, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(3, vec![7, 8, 8]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 12, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_211() -> Function { + Function { body: Block { ops: vec![Op::Call(199, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(5, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Return(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(397, vec![1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Call(789, vec![8, 9], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![8, 11], 1, false), Op::Call(207, vec![10, 12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(1, vec![15, 16]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(253, vec![14], 1, false)], ctrl: Ctrl::Return(2, vec![15, 16]) })].into_iter().collect(), None) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(202, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(212, vec![1, 2], 1, false), Op::Call(208, vec![7], 2, false)], ctrl: Ctrl::Return(3, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(203, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(209, vec![1], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(5, vec![9, 10]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 17, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_212() -> Function { + Function { body: Block { ops: vec![Op::Call(395, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Call(213, vec![7, 1], 1, false), Op::Call(213, vec![10, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 13, 11]), Op::Store(vec![14, 12, 15]), Op::Store(vec![14, 4, 16])], ctrl: Ctrl::Return(3, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 16, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_213() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(395, vec![3, 1], 1, false), Op::Call(263, vec![2, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_214() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(82)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(97)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 10, 11, 12, 13, 14, 10, 15, 16, 17, 18, 19, 20, 21, 22, 23, 1, 24, 25, 26, 2, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_215() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(19)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(177)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_216() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(39)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(210)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_217() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(202)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(32)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11, 12, 13, 14, 1, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_218() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(57)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(2)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 10, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_219() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(179)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(247)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_220() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(76)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(160)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 9, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_221() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(50)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(52)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(98)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 19, 13, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_222() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(55)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(14)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 10, 21, 22, 23, 24, 25, 26, 27, 28, 29, 21])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_223() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(121)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(9)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 16, 16, 22, 20, 23, 24, 20, 25, 26, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_224() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(191)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(139)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 18, 21, 18, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_225() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(25)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(183)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 21, 22, 23, 24, 25, 26, 27, 28, 29, 4])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_226() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(157)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(52)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(13)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_227() -> Function { + Function { body: Block { ops: vec![Op::Call(214, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(215, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(216, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(221, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(222, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(223, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(225, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![15]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 8, auxiliaries: 22, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_228() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::Call(216, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 6], 1, false), Op::Call(242, vec![7, 2], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 10, 9, 12])], ctrl: Ctrl::Return(0, vec![10, 13]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(1, vec![10, 11]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(2, vec![6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(214, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 10], 1, false), Op::Load(4, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![14], 1, false), Op::Call(241, vec![16], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![19, 20, 17, 20])], ctrl: Ctrl::Return(4, vec![18, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(5, vec![16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(6, vec![16, 17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(221, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(229, vec![1], 2, false)], ctrl: Ctrl::Return(7, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(222, vec![], 1, false), Op::Call(2, vec![0, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(229, vec![1], 2, false)], ctrl: Ctrl::Return(8, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(223, vec![], 1, false), Op::Call(2, vec![0, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(230, vec![1], 2, false)], ctrl: Ctrl::Return(9, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(225, vec![], 1, false), Op::Call(2, vec![0, 14], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(543, vec![0, 1, 2], 2, false)], ctrl: Ctrl::Return(10, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(215, vec![], 1, false), Op::Call(2, vec![0, 16], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20])], ctrl: Ctrl::Return(11, vec![20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 20], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![1, 22], 1, false), Op::Load(4, 21)], ctrl: Ctrl::Match(24, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 23)], ctrl: Ctrl::Match(28, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Call(786, vec![26, 30], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![34, 33, 32, 35])], ctrl: Ctrl::Return(12, vec![33, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![32, 32, 32, 32])], ctrl: Ctrl::Return(13, vec![32, 33]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![32, 32, 32, 32])], ctrl: Ctrl::Return(14, vec![32, 33]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![28, 28, 28, 28])], ctrl: Ctrl::Return(15, vec![28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![28, 28, 28, 28])], ctrl: Ctrl::Return(16, vec![28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18, 18])], ctrl: Ctrl::Return(17, vec![18, 19]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 41, lookups: 28 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_229() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![0, 4], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(232, vec![8], 1, false), Op::Call(241, vec![10], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![12, 13, 11, 13]), Op::Const(G::from_u64(2)), Op::Call(217, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17]), Op::Store(vec![15, 16, 18, 13]), Op::Const(G::from_u64(3)), Op::Store(vec![20, 19, 14, 13])], ctrl: Ctrl::Return(1, vec![17, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(2, vec![10, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 21, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_230() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![0, 4], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(224, vec![], 1, false), Op::Store(vec![13, 13, 13]), Op::Const(G::from_u64(0)), Op::Store(vec![14, 15, 16, 17])], ctrl: Ctrl::Return(1, vec![13, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13, 13])], ctrl: Ctrl::Return(2, vec![13, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(4, vec![10, 11]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 20, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_231() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(235, vec![2, 3], 2, false), Op::Call(231, vec![5], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_232() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(65)), Op::Call(233, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_233() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(235, vec![3, 4], 2, false), Op::Call(233, vec![6, 5], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_234() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(192)), Op::U8LessThan(0, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Sub(0, 5)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_235() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(194)), Op::U8LessThan(0, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(224)), Op::U8LessThan(0, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(192)), Op::Sub(0, 11), Op::Const(G::from_u64(64)), Op::Mul(12, 13), Op::Call(234, vec![9], 1, false), Op::Add(14, 15)], ctrl: Ctrl::Return(1, vec![16, 10]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(240)), Op::U8LessThan(0, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(224)), Op::Sub(0, 16), Op::Const(G::from_u64(4096)), Op::Mul(17, 18), Op::Call(234, vec![11], 1, false), Op::Const(G::from_u64(64)), Op::Mul(20, 21), Op::Call(234, vec![14], 1, false), Op::Add(22, 23), Op::Add(19, 24), Op::Const(G::from_u64(2048)), Op::U32LessThan(25, 26)], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![25, 15]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(240)), Op::Sub(0, 19), Op::Const(G::from_u64(262144)), Op::Mul(20, 21), Op::Call(234, vec![11], 1, false), Op::Const(G::from_u64(4096)), Op::Mul(23, 24), Op::Call(234, vec![14], 1, false), Op::Const(G::from_u64(64)), Op::Mul(26, 27), Op::Call(234, vec![17], 1, false), Op::Add(28, 29), Op::Add(25, 30), Op::Add(22, 31), Op::Const(G::from_u64(65536)), Op::U32LessThan(32, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![32, 18]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 26, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_236() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![1, 1, 1]), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4]), Op::Const(G::from_u64(2)), Op::Call(218, vec![], 1, false), Op::Store(vec![6, 7, 5, 1]), Op::Call(219, vec![], 1, false), Op::Store(vec![6, 9, 5, 1]), Op::Call(220, vec![], 1, false), Op::Store(vec![6, 11, 4, 1]), Op::Call(217, vec![], 1, false), Op::Store(vec![6, 13, 4, 1]), Op::Call(216, vec![], 1, false), Op::Store(vec![6, 15, 4, 1]), Op::Const(G::from_u64(3)), Op::Store(vec![17, 8, 12, 1]), Op::Store(vec![17, 10, 12, 1]), Op::Call(237, vec![0, 18, 19, 14], 1, false), Op::Store(vec![17, 16, 20, 1])], ctrl: Ctrl::Return(0, vec![21]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 18 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_237() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(235, vec![5, 6], 2, false), Op::Call(241, vec![7], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 9, 11]), Op::Const(G::from_u64(3)), Op::Store(vec![13, 3, 12, 11]), Op::Store(vec![13, 2, 14, 11]), Op::Call(237, vec![8, 1, 2, 3], 1, false), Op::Store(vec![13, 15, 16, 11])], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_238() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(295, vec![7], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23]), Op::Call(344, vec![14, 24], 1, false), Op::Load(4, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![28, 4, 30], 1, false), Op::Call(431, vec![31, 1], 1, false)], ctrl: Ctrl::Return(0, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![30, 25, 4, 31]), Op::Call(431, vec![32, 1], 1, false)], ctrl: Ctrl::Return(1, vec![33]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 31, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_239() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(236, vec![4], 1, false), Op::Call(238, vec![6, 1], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_240() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(134, vec![0, 1], 2, false), Op::Call(134, vec![3, 1], 2, false), Op::Call(134, vec![5, 1], 2, false), Op::Call(134, vec![7, 1], 2, false)], ctrl: Ctrl::Return(0, vec![2, 4, 6, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_241() -> Function { + Function { body: Block { ops: vec![Op::Call(240, vec![0], 4, true), Op::Const(G::from_u64(0)), Op::U8Xor(1, 5), Op::U8Xor(2, 5), Op::U8Xor(3, 5), Op::U8Xor(4, 5), Op::Const(G::from_u64(256)), Op::Mul(10, 7), Op::Const(G::from_u64(65536)), Op::Mul(12, 8), Op::Const(G::from_u64(16777216)), Op::Mul(14, 9), Op::Add(13, 15), Op::Add(11, 16), Op::Add(6, 17), Op::AssertEq(vec![0], vec![18], Some("u32 byte split does not recompose to the original value".into())), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19]), Op::Store(vec![5, 6, 7, 8, 9, 5, 5, 5, 5, 20]), Op::Call(130, vec![21], 1, false)], ctrl: Ctrl::Return(0, vec![22]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_242() -> Function { + Function { body: Block { ops: vec![Op::Call(425, vec![0, 1], 1, false), Op::Call(122, vec![2], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(218, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![4], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(0, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(1, vec![12, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(219, vec![], 1, false), Op::Call(2, vec![6, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Return(2, vec![13, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![4], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(789, vec![4, 14], 1, false), Op::Call(243, vec![15, 1], 2, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19])], ctrl: Ctrl::Return(3, vec![18, 20]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(789, vec![4, 18], 1, false), Op::Call(242, vec![19, 1], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![22, 21]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(248, vec![17, 21], 1, false)], ctrl: Ctrl::Return(5, vec![22, 23]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(6, vec![14, 16]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(7, vec![9, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 8, auxiliaries: 22, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_243() -> Function { + Function { body: Block { ops: vec![Op::Call(244, vec![0], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(425, vec![0, 1], 1, false), Op::Call(244, vec![4], 2, false)], ctrl: Ctrl::Return(1, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_244() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(217, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(11, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(245, vec![13], 2, false)], ctrl: Ctrl::Return(1, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![15, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![15, 15]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9, 9]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![5, 5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 18, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_245() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Add(8, 9), Op::Add(7, 21), Op::Add(6, 22), Op::Add(5, 23), Op::EqZero(24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![26, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(3, 26), Op::Const(G::from_u64(65536)), Op::Mul(4, 28), Op::Add(27, 29), Op::Add(2, 30), Op::Const(G::from_u64(55296)), Op::U32LessThan(31, 32)], ctrl: Ctrl::Match(33, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![34, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(57343)), Op::U32LessThan(34, 31)], ctrl: Ctrl::Match(35, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![36, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1114112)), Op::U32LessThan(31, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![38, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![38, 38]) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![21, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![11, 11]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 45, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_246() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::U32LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(64)), Op::Sub(0, 4), Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(246, vec![5, 7], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_247() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(246, vec![0, 1], 2, false), Op::Call(246, vec![3, 1], 2, false), Op::Call(246, vec![5, 1], 2, false)], ctrl: Ctrl::Return(0, vec![2, 4, 6, 7]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_248() -> Function { + Function { body: Block { ops: vec![Op::Call(247, vec![0], 4, true), Op::Const(G::from_u64(0)), Op::U8Xor(2, 6), Op::U8Xor(3, 6), Op::U8Xor(4, 6), Op::U8Xor(5, 6), Op::Const(G::from_u64(64)), Op::U32LessThan(7, 11), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("utf8 group 0 is not a 6-bit value".into())), Op::U32LessThan(8, 11), Op::AssertEq(vec![14], vec![13], Some("utf8 group 1 is not a 6-bit value".into())), Op::U32LessThan(9, 11), Op::AssertEq(vec![15], vec![13], Some("utf8 group 2 is not a 6-bit value".into())), Op::U32LessThan(10, 11), Op::AssertEq(vec![16], vec![13], Some("utf8 group 3 is not a 6-bit value".into())), Op::Mul(8, 11), Op::Const(G::from_u64(4096)), Op::Mul(9, 18), Op::Const(G::from_u64(262144)), Op::Mul(10, 20), Op::Add(19, 21), Op::Add(17, 22), Op::Add(7, 23), Op::AssertEq(vec![0], vec![24], Some("utf8 groups do not recompose to the codepoint".into())), Op::Const(G::from_u64(128)), Op::U32LessThan(0, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![27, 0, 1])], ctrl: Ctrl::Return(0, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2048)), Op::U32LessThan(0, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Add(7, 29), Op::Const(G::from_u64(192)), Op::Add(8, 31), Op::Const(G::from_u64(0)), Op::Store(vec![33, 30, 1]), Op::Store(vec![33, 32, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(65536)), Op::U32LessThan(0, 29)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Add(7, 31), Op::Add(8, 31), Op::Const(G::from_u64(224)), Op::Add(9, 34), Op::Const(G::from_u64(0)), Op::Store(vec![36, 32, 1]), Op::Store(vec![36, 33, 37]), Op::Store(vec![36, 35, 38])], ctrl: Ctrl::Return(2, vec![39]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(128)), Op::Add(7, 31), Op::Add(8, 31), Op::Add(9, 31), Op::Const(G::from_u64(240)), Op::Add(10, 35), Op::Const(G::from_u64(0)), Op::Store(vec![37, 32, 1]), Op::Store(vec![37, 33, 38]), Op::Store(vec![37, 34, 39]), Op::Store(vec![37, 36, 40])], ctrl: Ctrl::Return(3, vec![41]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 58, lookups: 51 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_249() -> Function { + Function { body: Block { ops: vec![Op::Call(156, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(157, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(170, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(171, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(172, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(175, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(174, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(182, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(183, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(178, vec![], 1, false), Op::Call(2, vec![0, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![], 1, false), Op::Call(2, vec![0, 27], 1, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![], 1, false), Op::Call(2, vec![0, 29], 1, false)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(181, vec![], 1, false), Op::Call(2, vec![0, 31], 1, false)], ctrl: Ctrl::Match(32, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(16, vec![33]) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 17, auxiliaries: 49, lookups: 33 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_250() -> Function { + Function { body: Block { ops: vec![Op::Call(160, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false), Op::Call(161, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false), Op::Call(162, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false), Op::Call(163, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false), Op::Call(164, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false), Op::Call(165, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false), Op::Call(166, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false), Op::Call(167, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false), Op::Call(168, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false), Op::Call(169, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(8, 25), Op::Add(6, 26), Op::Add(4, 27), Op::Add(2, 28)], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_251() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(1, vec![5, 7]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(155, vec![], 1, false), Op::Call(2, vec![2, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(2, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8])], ctrl: Ctrl::Return(3, vec![7, 9]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(252, vec![2, 3], 2, false)], ctrl: Ctrl::Return(4, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(5, vec![5, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_252() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(156, vec![], 1, false), Op::Call(2, vec![3, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(251, vec![1], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(123, vec![9], 1, false)], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(1, vec![10, 12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(2, vec![8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(3, vec![6, 8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_253() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![1, 2, 0, 2])], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_254() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(251, vec![3], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(158, vec![], 1, false), Op::Call(2, vec![6, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(130, vec![10], 1, false)], ctrl: Ctrl::Return(0, vec![13, 14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(159, vec![], 1, false), Op::Call(2, vec![6, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(123, vec![10], 1, false), Op::Call(130, vec![16], 1, false)], ctrl: Ctrl::Return(1, vec![15, 15, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16, 16, 16])], ctrl: Ctrl::Return(2, vec![15, 15, 17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(3, vec![11, 11, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(4, vec![9, 9, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(5, vec![5, 5, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 18, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_255() -> Function { + Function { body: Block { ops: vec![Op::Call(130, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Call(141, vec![2], 1, false), Op::Sub(3, 4), Op::Mul(0, 5)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Call(158, vec![], 1, false)], ctrl: Ctrl::Yield(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(159, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![7]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(133, vec![2], 1, false), Op::Call(130, vec![8], 1, false)], ctrl: Ctrl::Yield(3, vec![9]) })), 1, 3, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Const(G::from_u64(0)), Op::Store(vec![10, 7, 12, 13]), Op::Call(253, vec![8], 1, false), Op::Store(vec![9, 14, 15, 13])], ctrl: Ctrl::Return(4, vec![16]) })) })) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 15, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_256() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(125, vec![1, 3], 1, false), Op::Call(255, vec![0, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(132, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(131, vec![3, 1], 1, false), Op::Call(255, vec![2, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(131, vec![1, 3], 1, false), Op::Call(255, vec![0, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_257() -> Function { + Function { body: Block { ops: vec![Op::Call(141, vec![2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(255, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(144, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(141, vec![4], 1, false), Op::Sub(5, 6), Op::Mul(0, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(131, vec![2, 4], 1, false), Op::Call(255, vec![9, 10], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(255, vec![9, 4], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_258() -> Function { + Function { body: Block { ops: vec![Op::Call(141, vec![3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6]), Op::Call(255, vec![5, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(143, vec![1, 3], 1, false), Op::Call(144, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(141, vec![6], 1, false), Op::Sub(7, 8), Op::Mul(0, 9)], ctrl: Ctrl::MatchContinue(10, [(G::from_u64(1), Block { ops: vec![Op::Call(123, vec![5], 1, false)], ctrl: Ctrl::Yield(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![5]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(0, 2), Op::Mul(12, 13), Op::Sub(2, 14), Op::Add(0, 15), Op::Const(G::from_u64(1)), Op::Call(141, vec![11], 1, false), Op::Sub(17, 18), Op::Mul(16, 19), Op::Call(255, vec![20, 11], 1, false)], ctrl: Ctrl::Return(3, vec![21]) })) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 13, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_259() -> Function { + Function { body: Block { ops: vec![Op::Call(141, vec![2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(255, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(144, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(141, vec![4], 1, false), Op::Sub(5, 6), Op::Mul(0, 7)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(1), Block { ops: vec![Op::Call(131, vec![2, 4], 1, false)], ctrl: Ctrl::Yield(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![4]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12]), Op::Store(vec![10, 11, 10, 10, 10, 10, 10, 10, 10, 13]), Op::Call(123, vec![2], 1, false), Op::Call(143, vec![15, 14], 1, false), Op::Call(132, vec![16, 9], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(131, vec![2, 9], 1, false), Op::Call(255, vec![18, 19], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(255, vec![18, 9], 1, false)], ctrl: Ctrl::Return(4, vec![19]) }))) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 15, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_260() -> Function { + Function { body: Block { ops: vec![Op::Call(141, vec![2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]), Op::Call(255, vec![4, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(144, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(141, vec![4], 1, false), Op::Sub(5, 6), Op::Mul(0, 7)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(1), Block { ops: vec![Op::Call(131, vec![2, 4], 1, false)], ctrl: Ctrl::Yield(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![4]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Call(143, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(141, vec![4], 1, false), Op::Sub(11, 12), Op::Mul(0, 13)], ctrl: Ctrl::MatchContinue(14, [(G::from_u64(1), Block { ops: vec![Op::Call(123, vec![10], 1, false)], ctrl: Ctrl::Yield(3, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(4, vec![10]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(141, vec![15], 1, false), Op::Sub(16, 17), Op::Mul(0, 18), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16, 16, 16]), Op::Store(vec![20, 21, 20, 20, 20, 20, 20, 20, 20, 22]), Op::Call(123, vec![2], 1, false), Op::Call(143, vec![24, 23], 1, false), Op::Call(132, vec![25, 9], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Call(255, vec![19, 15], 1, false)], ctrl: Ctrl::Return(5, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28]), Op::Store(vec![27, 28, 27, 27, 27, 27, 27, 27, 27, 29]), Op::Call(256, vec![19, 15, 27, 30], 1, false)], ctrl: Ctrl::Return(6, vec![31]) }))) })) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 24, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_261() -> Function { + Function { body: Block { ops: vec![Op::Call(395, vec![1, 2], 1, false), Op::Call(787, vec![3], 1, false), Op::Call(163, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false), Op::Call(168, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false), Op::Add(6, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(4, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(0, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![3, 12], 1, false), Op::Call(254, vec![13], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(168, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::MatchContinue(18, [(G::from_u64(1), Block { ops: vec![Op::Call(253, vec![16], 1, false)], ctrl: Ctrl::Yield(1, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(19, 15), Op::Call(141, vec![16], 1, false), Op::Sub(19, 21), Op::Mul(20, 22), Op::Call(255, vec![23, 16], 1, false)], ctrl: Ctrl::Yield(2, vec![24]) })), 1, 4, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(798, vec![3, 20], 1, false), Op::Call(263, vec![19, 21], 1, false)], ctrl: Ctrl::Return(3, vec![20, 22]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(4, vec![17, 18]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(4, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(5, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![3, 12], 1, false), Op::Call(254, vec![13], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(262, vec![0, 3, 15, 16], 2, false)], ctrl: Ctrl::Return(6, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(7, vec![17, 18]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 27, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_262() -> Function { + Function { body: Block { ops: vec![Op::Call(166, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Call(167, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false), Op::Call(169, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false), Op::Add(7, 9), Op::Add(5, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(789, vec![1, 12], 1, false), Op::Call(251, vec![13], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(166, vec![], 1, false), Op::Call(2, vec![0, 16], 1, false)], ctrl: Ctrl::MatchContinue(17, [(G::from_u64(1), Block { ops: vec![Op::Call(259, vec![2, 3, 15], 1, false)], ctrl: Ctrl::Yield(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(167, vec![], 1, false), Op::Call(2, vec![0, 18], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Call(260, vec![2, 3, 15], 1, false)], ctrl: Ctrl::Yield(1, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22]), Op::Store(vec![20, 21, 20, 20, 20, 20, 20, 20, 20, 23]), Op::Call(144, vec![15, 24], 1, false), Op::Call(141, vec![25], 1, false), Op::Sub(22, 26), Op::Mul(2, 27), Op::Call(146, vec![3, 15], 1, false), Op::Call(255, vec![28, 29], 1, false)], ctrl: Ctrl::Yield(2, vec![30]) }))) })), 1, 11, 8, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(798, vec![1, 20], 1, false), Op::Call(263, vec![18, 21], 1, false)], ctrl: Ctrl::Return(3, vec![19, 22]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(4, vec![16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(789, vec![1, 12], 1, false), Op::Call(254, vec![13], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(160, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::MatchContinue(18, [(G::from_u64(1), Block { ops: vec![Op::Call(256, vec![2, 3, 15, 16], 1, false)], ctrl: Ctrl::Yield(5, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(161, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(21, 15), Op::Call(141, vec![16], 1, false), Op::Sub(21, 23), Op::Mul(22, 24), Op::Call(256, vec![2, 3, 25, 16], 1, false)], ctrl: Ctrl::Yield(6, vec![26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(162, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(2, 15), Op::Mul(23, 24), Op::Sub(15, 25), Op::Add(2, 26), Op::Const(G::from_u64(1)), Op::Call(141, vec![3], 1, false), Op::Sub(28, 29), Op::Call(141, vec![16], 1, false), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(27, 33), Op::Call(137, vec![3, 16], 1, false), Op::Call(255, vec![34, 35], 1, false)], ctrl: Ctrl::Yield(7, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(164, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Call(257, vec![2, 3, 16], 1, false)], ctrl: Ctrl::Yield(8, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(258, vec![2, 3, 15, 16], 1, false)], ctrl: Ctrl::Yield(9, vec![25]) }))) }))) }))) })), 1, 13, 8, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(798, vec![1, 21], 1, false), Op::Call(263, vec![19, 22], 1, false)], ctrl: Ctrl::Return(10, vec![20, 23]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(11, vec![17, 18]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 12, auxiliaries: 30, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_263() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 0, 3, 6]), Op::Call(263, vec![7, 4], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_264() -> Function { + Function { body: Block { ops: vec![Op::Call(170, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(125, vec![1, 2], 1, false), Op::Call(130, vec![6], 1, false), Op::Call(253, vec![7], 1, false)], ctrl: Ctrl::Return(0, vec![5, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(171, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(131, vec![1, 2], 1, false), Op::Call(130, vec![8], 1, false), Op::Call(253, vec![9], 1, false)], ctrl: Ctrl::Return(1, vec![7, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(172, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(137, vec![1, 2], 1, false), Op::Call(130, vec![10], 1, false), Op::Call(253, vec![11], 1, false)], ctrl: Ctrl::Return(2, vec![9, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(143, vec![1, 2], 1, false), Op::Call(130, vec![12], 1, false), Op::Call(253, vec![13], 1, false)], ctrl: Ctrl::Return(3, vec![11, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(175, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(144, vec![1, 2], 1, false), Op::Call(130, vec![14], 1, false), Op::Call(253, vec![15], 1, false)], ctrl: Ctrl::Return(4, vec![13, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(174, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(145, vec![1, 2], 1, false), Op::Call(130, vec![16], 1, false), Op::Call(253, vec![17], 1, false)], ctrl: Ctrl::Return(5, vec![15, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(146, vec![1, 2], 1, false), Op::Call(130, vec![18], 1, false), Op::Call(253, vec![19], 1, false)], ctrl: Ctrl::Return(6, vec![17, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(150, vec![1, 2], 1, false), Op::Call(130, vec![20], 1, false), Op::Call(253, vec![21], 1, false)], ctrl: Ctrl::Return(7, vec![19, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(178, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(151, vec![1, 2], 1, false), Op::Call(130, vec![22], 1, false), Op::Call(253, vec![23], 1, false)], ctrl: Ctrl::Return(8, vec![21, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(152, vec![1, 2], 1, false), Op::Call(130, vec![24], 1, false), Op::Call(253, vec![25], 1, false)], ctrl: Ctrl::Return(9, vec![23, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(153, vec![1, 2], 1, false), Op::Call(130, vec![26], 1, false), Op::Call(253, vec![27], 1, false)], ctrl: Ctrl::Return(10, vec![25, 28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(181, vec![], 1, false), Op::Call(2, vec![0, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(154, vec![1, 2], 1, false), Op::Call(130, vec![28], 1, false), Op::Call(253, vec![29], 1, false)], ctrl: Ctrl::Return(11, vec![27, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(182, vec![], 1, false), Op::Call(2, vec![0, 27], 1, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(346, vec![1, 2], 1, false), Op::Call(206, vec![30], 1, false)], ctrl: Ctrl::Return(12, vec![29, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(183, vec![], 1, false), Op::Call(2, vec![0, 29], 1, false)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(132, vec![1, 2], 1, false), Op::Call(206, vec![32], 1, false)], ctrl: Ctrl::Return(13, vec![31, 33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![31, 31, 31, 31])], ctrl: Ctrl::Return(14, vec![31, 32]) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 15, auxiliaries: 44, lookups: 31 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_265() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(170, vec![], 1, false), Op::Call(2, vec![3, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![8, 0, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::Const(G::from_u64(2)), Op::Sub(8, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![1, 13], 1, false), Op::Load(4, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![19, 12, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(2, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(3, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(4, vec![11, 0, 13]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(5, vec![6, 0, 8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_266() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3, 3, 3, 3, 3, 3, 3, 3]), Op::Store(vec![2, 3, 2, 2, 2, 2, 2, 2, 2, 4]), Op::Call(131, vec![1, 5], 1, false), Op::Call(130, vec![6], 1, false), Op::Const(G::from_u64(2)), Op::Call(156, vec![], 1, false), Op::Store(vec![3, 3, 3]), Op::Store(vec![8, 9, 10, 2]), Op::Call(141, vec![7], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 11, 0, 14])], ctrl: Ctrl::Return(0, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(170, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Const(G::from_u64(0)), Op::Store(vec![13, 14, 16, 17]), Op::Const(G::from_u64(7)), Op::Store(vec![19, 17, 7, 17]), Op::Const(G::from_u64(3)), Op::Store(vec![21, 18, 0, 17]), Op::Store(vec![21, 22, 20, 17]), Op::Store(vec![21, 11, 23, 17])], ctrl: Ctrl::Return(1, vec![24]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_267() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Load(4, 5)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Call(265, vec![5, 6], 3, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(130, vec![13], 1, false), Op::Call(141, vec![14], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![12, 14], 1, false)], ctrl: Ctrl::Return(2, vec![16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 19, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_268() -> Function { + Function { body: Block { ops: vec![Op::Call(141, vec![1], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(263, vec![0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(170, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 7, 8]), Op::Const(G::from_u64(3)), Op::Store(vec![10, 9, 0, 8]), Op::Call(253, vec![1], 1, false), Op::Store(vec![10, 11, 12, 8]), Op::Call(263, vec![13, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6, 14]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_269() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(4), Block { ops: vec![Op::Call(122, vec![7], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(156, vec![], 1, false), Op::Call(2, vec![12, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Sub(17, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![10, 20], 1, false), Op::Load(4, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::EqZero(23)], ctrl: Ctrl::Return(1, vec![26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![20]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![9]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 26, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_270() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(789, vec![0, 4], 1, false), Op::Call(251, vec![7], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(1, vec![10, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Add(1, 2), Op::Const(G::from_u64(1)), Op::Add(10, 11), Op::Call(789, vec![0, 12], 1, false), Op::Call(269, vec![13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(789, vec![0, 10], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 16), Op::Call(798, vec![0, 17], 1, false), Op::Call(251, vec![15], 2, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(125, vec![20, 9], 1, false), Op::Call(253, vec![22], 1, false), Op::Call(263, vec![23, 18], 1, false)], ctrl: Ctrl::Return(3, vec![21, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(268, vec![15, 9, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }))) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 21, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_271() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::Call(157, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Call(156, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 10], 1, false), Op::Call(251, vec![11], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(798, vec![1, 14], 1, false), Op::Call(123, vec![13], 1, false), Op::Call(253, vec![16], 1, false), Op::Call(263, vec![17, 15], 1, false)], ctrl: Ctrl::Return(1, vec![14, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(2, vec![14, 15]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 10], 1, false), Op::Call(251, vec![11], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(798, vec![1, 14], 1, false), Op::Call(133, vec![13], 1, false), Op::Call(130, vec![16], 1, false), Op::Call(253, vec![17], 1, false), Op::Call(263, vec![18, 15], 1, false)], ctrl: Ctrl::Return(4, vec![14, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(5, vec![14, 15]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(272, vec![0, 1, 3], 2, false)], ctrl: Ctrl::Return(6, vec![8, 9]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 22, lookups: 19 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_272() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(2, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![1, 7], 1, false), Op::Call(251, vec![6], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(251, vec![8], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(264, vec![0, 10, 12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(798, vec![1, 15], 1, false), Op::Const(G::from_u64(1)), Op::Call(263, vec![14, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13, 13])], ctrl: Ctrl::Return(3, vec![13, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(251, vec![8], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(273, vec![0, 6, 12, 1], 2, false)], ctrl: Ctrl::Return(4, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13, 13])], ctrl: Ctrl::Return(5, vec![13, 14]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_273() -> Function { + Function { body: Block { ops: vec![Op::Call(170, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Call(176, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false), Op::Call(175, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false), Op::Add(7, 9), Op::Const(G::from_u64(1)), Op::Call(141, vec![2], 1, false), Op::Sub(11, 12), Op::Call(133, vec![2], 1, false), Op::Call(130, vec![14], 1, false), Op::Call(141, vec![15], 1, false), Op::Sub(11, 16), Op::Mul(13, 17), Op::Mul(10, 18), Op::Add(5, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![21, 21, 21, 21])], ctrl: Ctrl::Return(0, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(798, vec![3, 21], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(268, vec![1, 2, 22], 2, false)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(1, vec![25, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![25, 25, 25, 25])], ctrl: Ctrl::Return(2, vec![25, 26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(274, vec![0, 1, 2, 22], 1, false)], ctrl: Ctrl::Return(3, vec![23, 24]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 19, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_274() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![4, 0, 6, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 8, 1, 7]), Op::Call(253, vec![2], 1, false), Op::Store(vec![9, 10, 11, 7]), Op::Call(263, vec![12, 3], 1, false)], ctrl: Ctrl::Return(0, vec![13]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_275() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1, 2, 3, 4, 5, 6, 7, 8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(275, vec![12, 11, 2, 3, 4, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(2, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(275, vec![12, 1, 11, 3, 4, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(3, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(275, vec![12, 1, 2, 11, 4, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(4, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(275, vec![12, 1, 2, 3, 11, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(5, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(275, vec![12, 1, 2, 3, 4, 11, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(6, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(275, vec![12, 1, 2, 3, 4, 5, 11, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(7, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Call(275, vec![12, 1, 2, 3, 4, 5, 6, 11, 8, 13], 8, false)], ctrl: Ctrl::Return(8, vec![14, 15, 16, 17, 18, 19, 20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(275, vec![12, 1, 2, 3, 4, 5, 6, 7, 11, 13], 8, false)], ctrl: Ctrl::Return(9, vec![14, 15, 16, 17, 18, 19, 20, 21]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 10, selectors: 10, auxiliaries: 20, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_276() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Call(276, vec![4, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_277() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(275, vec![0, 1, 1, 1, 1, 1, 1, 1, 1, 1], 8, false), Op::Const(G::from_u64(8)), Op::Call(276, vec![0, 10], 1, false), Op::Load(3, 11)], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Yield(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(277, vec![11], 1, false)], ctrl: Ctrl::Yield(1, vec![15]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Load(10, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Call(7, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![27, 27, 27, 27, 27, 27, 27, 27, 27, 27])], ctrl: Ctrl::Return(2, vec![28]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28]), Op::Store(vec![27, 2, 3, 4, 5, 6, 7, 8, 9, 29])], ctrl: Ctrl::Return(3, vec![30]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 2, 3, 4, 5, 6, 7, 8, 9, 15])], ctrl: Ctrl::Return(4, vec![27]) }))) })) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 29, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_278() -> Function { + Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(278, vec![2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(278, vec![2], 1, false), Op::Call(278, vec![3], 1, false), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(2, vec![13]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(278, vec![2], 1, false), Op::Call(278, vec![3], 1, false), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(3, vec![13]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 13, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_279() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Call(19, vec![3, 4, 5, 6, 7, 8, 9, 10], 1, false), Op::Call(789, vec![1, 12], 1, false), Op::Const(G::from_u64(0)), Op::Call(278, vec![13], 1, false), Op::Call(279, vec![11, 1], 1, false), Op::Store(vec![14, 15, 16])], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_280() -> Function { + Function { body: Block { ops: vec![Op::Load(18, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(789, vec![4, 23], 1, false), Op::Const(G::from_u64(1)), Op::Call(278, vec![24], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![25, 26, 27, 27])], ctrl: Ctrl::Return(0, vec![28]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Store(vec![23, 24, 23, 23])], ctrl: Ctrl::Return(1, vec![25]) }), (G::from_u64(2), Block { ops: vec![Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(789, vec![2, 23], 1, false), Op::Call(279, vec![14, 4], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 25, 27])], ctrl: Ctrl::Return(2, vec![28]) }), (G::from_u64(3), Block { ops: vec![Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(789, vec![3, 23], 1, false), Op::Call(279, vec![14, 4], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 25, 27])], ctrl: Ctrl::Return(3, vec![28]) }), (G::from_u64(4), Block { ops: vec![Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(789, vec![2, 23], 1, false), Op::Const(G::from_u64(8)), Op::Call(19, vec![14, 15, 16, 17, 18, 19, 20, 21], 1, false), Op::Call(280, vec![22, 1, 2, 3, 4], 1, false), Op::Store(vec![25, 24, 26, 27])], ctrl: Ctrl::Return(4, vec![28]) }), (G::from_u64(5), Block { ops: vec![Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(789, vec![2, 23], 1, false), Op::Call(292, vec![24], 1, false), Op::Call(231, vec![25], 0, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 27, 25, 28])], ctrl: Ctrl::Return(5, vec![29]) }), (G::from_u64(6), Block { ops: vec![Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(789, vec![2, 23], 1, false), Op::Call(292, vec![24], 1, false), Op::Call(277, vec![25], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![27, 28, 26, 28])], ctrl: Ctrl::Return(6, vec![29]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(280, vec![6, 1, 2, 3, 4], 1, false), Op::Call(280, vec![7, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(7, vec![27]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(280, vec![9, 1, 2, 3, 4], 1, false), Op::Call(280, vec![10, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(8, vec![27]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(280, vec![11, 1, 2, 3, 4], 1, false), Op::Call(280, vec![12, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(9, vec![27]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(280, vec![11, 1, 2, 3, 4], 1, false), Op::Call(280, vec![12, 1, 2, 3, 4], 1, false), Op::Call(280, vec![13, 1, 2, 3, 4], 1, false), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(10, vec![27]) }), (G::from_u64(11), Block { ops: vec![Op::Call(19, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(798, vec![1, 23], 1, false), Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Call(280, vec![26, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(11, vec![28]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 12, auxiliaries: 25, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_281() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![10, 12, 13, 14, 15], 1, false), Op::Call(280, vec![11, 12, 13, 14, 15], 1, false), Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![20, 19, 17, 18, 1, 16, 21, 21, 21, 21, 21, 21]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![20]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![21, 19, 17, 18, 20, 22, 22, 22, 22, 22, 22, 22]) })) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20, 19, 17, 18, 21, 21, 21, 21, 21, 21, 21, 21]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 17, selectors: 5, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_282() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(0)), Op::Call(19, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![15, 16, 14, 0, 15, 15, 15, 15, 15, 15, 15, 15]) }))) }, layout: FunctionLayout { input_size: 14, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_283() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(4)), Op::Call(19, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![15, 16, 14, 0, 17, 17, 17, 17, 17, 17, 17, 17]) }))) }, layout: FunctionLayout { input_size: 14, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_284() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![37]) }), (G::from_u64(0), Block { ops: vec![Op::Call(284, vec![36], 1, false), Op::Const(G::from_u64(1)), Op::Add(37, 38)], ctrl: Ctrl::Return(1, vec![39]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 38, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_285() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(285, vec![37, 39], 34, false)], ctrl: Ctrl::Return(1, vec![40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 72, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_286() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![25, 29, 30, 31, 32], 1, false), Op::Const(G::from_u64(5)), Op::Call(19, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(19, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(19, vec![17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Call(284, vec![26], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![34, 35, 33, 36, 37, 38, 0, 27, 28, 39, 39, 39]) }))) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_287() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![33, 36, 37, 38, 39], 1, false), Op::Const(G::from_u64(6)), Op::Call(19, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(19, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(19, vec![17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Call(19, vec![25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![41, 42, 40, 34, 35, 43, 44, 45, 0, 46, 46, 46]) }))) }, layout: FunctionLayout { input_size: 40, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_288() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17, 17, 17])], ctrl: Ctrl::Return(0, vec![18]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![15, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(19, vec![7, 8, 9, 10, 11, 12, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 20), Op::Call(288, vec![16, 1, 2, 3, 4, 21], 1, false), Op::Store(vec![18, 5, 19, 17, 22])], ctrl: Ctrl::Return(1, vec![23]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 16, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_289() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![42, 46, 47, 48, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(288, vec![43, 46, 47, 48, 49, 51], 1, false), Op::Const(G::from_u64(7)), Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(19, vec![10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Call(19, vec![18, 19, 20, 21, 22, 23, 24, 25], 1, false), Op::Call(19, vec![26, 27, 28, 29, 30, 31, 32, 33], 1, false), Op::Call(19, vec![34, 35, 36, 37, 38, 39, 40, 41], 1, false)], ctrl: Ctrl::Return(0, vec![53, 54, 50, 55, 56, 57, 58, 52, 0, 1, 44, 45]) }))) }, layout: FunctionLayout { input_size: 50, selectors: 1, auxiliaries: 8, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_290() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(2)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(5, vec![33, 34, 35], 1, false), Op::Call(23, vec![36, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 0, false), Op::Call(121, vec![36], 49, false), Op::Load(3, 85), Op::Const(G::from_u64(1)), Op::AssertEq(vec![86, 87, 88], vec![89, 89, 89], Some("trailing bytes after constant on ch 2".into()))], ctrl: Ctrl::Return(0, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 88, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_291() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(3)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(4, vec![33, 34, 35], 1, true), Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![38]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 39, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_292() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(4)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(5, vec![33, 34, 35], 1, false), Op::Call(23, vec![36, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 0, false)], ctrl: Ctrl::Return(0, vec![36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 36, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_293() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![2]) }))) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![2]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_294() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(293, vec![0, 1], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(303, vec![12, 13], 1, false)], ctrl: Ctrl::Return(1, vec![15]) }))) }))) }, layout: FunctionLayout { input_size: 14, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_295() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(291, vec![0], 1, true)], ctrl: Ctrl::MatchContinue(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(293, vec![2, 3], 1, false)], ctrl: Ctrl::Match(50, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51])], ctrl: Ctrl::Yield(0, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![52, 52, 52]), Op::Store(vec![51, 0, 53])], ctrl: Ctrl::Yield(1, vec![54]) }))) })), 1, 4, 3, Box::new(Block { ops: vec![Op::Call(281, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 46, 47, 50, 48, 49], 12, false), Op::Store(vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62])], ctrl: Ctrl::Return(2, vec![63]) })) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49]), Op::Call(282, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 46, 47, 50, 48], 12, false), Op::Store(vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62])], ctrl: Ctrl::Return(3, vec![63]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49]), Op::Call(283, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 46, 47, 50, 48], 12, false), Op::Store(vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62])], ctrl: Ctrl::Return(4, vec![63]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![0, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(5, vec![49]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(297, vec![10, 49], 1, false)], ctrl: Ctrl::Return(6, vec![50]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(19, vec![10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Call(298, vec![18, 49, 50], 1, false)], ctrl: Ctrl::Return(7, vec![51]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(299, vec![10, 49], 1, false)], ctrl: Ctrl::Return(8, vec![50]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![50, 50, 50]), Op::Store(vec![49, 0, 51]), Op::Call(289, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 0, 49, 46, 47, 52, 48], 12, false), Op::Store(vec![53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64])], ctrl: Ctrl::Return(9, vec![65]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 1, selectors: 10, auxiliaries: 68, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_296() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![9], 48, false)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(8), Block { ops: vec![Op::Call(791, vec![11, 1, 2, 3, 4, 5, 6, 7, 8], 45, false)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Call(291, vec![0], 1, true), Op::Call(294, vec![59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 11, 9], 1, false), Op::Call(281, vec![59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 55, 56, 104, 57, 103], 12, false), Op::Store(vec![105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116])], ctrl: Ctrl::Return(0, vec![117]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 109, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_297() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Call(300, vec![3, 1], 45, false)], ctrl: Ctrl::Match(50, [(G::from_u64(1), Block { ops: vec![Op::Call(303, vec![3, 0], 1, false), Op::Call(286, vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 0, 1, 47, 48, 95, 49], 12, false), Op::Store(vec![96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107])], ctrl: Ctrl::Return(0, vec![108]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 108, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_298() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(8), Block { ops: vec![Op::Call(300, vec![4, 1], 45, false)], ctrl: Ctrl::Match(51, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(52, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(285, vec![78, 2], 34, false), Op::Call(303, vec![4, 0], 1, false), Op::Call(287, vec![96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 0, 1, 48, 49, 130, 50], 12, false), Op::Store(vec![131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142])], ctrl: Ctrl::Return(0, vec![143]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 142, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_299() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Call(300, vec![3, 1], 45, false)], ctrl: Ctrl::Match(50, [(G::from_u64(2), Block { ops: vec![Op::Call(303, vec![3, 0], 1, false), Op::Call(289, vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 0, 1, 47, 48, 95, 49], 12, false), Op::Store(vec![96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107])], ctrl: Ctrl::Return(0, vec![108]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 108, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_300() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 49), Op::Call(300, vec![48, 50], 45, false)], ctrl: Ctrl::Return(1, vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 94, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_301() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::Call(19, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::AssertEq(vec![9], vec![0], Some("projection index bytes do not recompose to the index".into()))], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_302() -> Function { + Function { body: Block { ops: vec![Op::Call(300, vec![0, 2], 45, false), Op::Call(301, vec![2], 8, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![56, 48, 49, 50, 51, 52, 53, 54, 55, 1, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(1, vec![56, 48, 49, 50, 51, 52, 53, 54, 55, 1, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![56, 48, 49, 50, 51, 52, 53, 54, 55, 1, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57]) })].into_iter().collect(), None, 45, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![101, 101, 101]), Op::Call(78, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 102, 102, 102, 102], 1, false), Op::Call(24, vec![103], 1, false)], ctrl: Ctrl::Return(3, vec![104]) })) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 102, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_303() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(304, vec![0, 1, 0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_304() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51])], ctrl: Ctrl::Return(0, vec![52]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(302, vec![0, 1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 53), Op::Call(304, vec![0, 1, 50, 54], 1, false), Op::Store(vec![51, 52, 55])], ctrl: Ctrl::Return(1, vec![56]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 51, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_305() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![4]) }), (G::from_u64(2), Block { ops: vec![Op::Call(305, vec![2], 1, false), Op::Call(305, vec![3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![6]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(305, vec![3], 1, false)], ctrl: Ctrl::Return(6, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_306() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(306, vec![3, 6], 1, false)], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(306, vec![3, 6], 1, false), Op::Call(306, vec![4, 7], 1, false), Op::Mul(8, 9)], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(3), Block { ops: vec![Op::Call(306, vec![3, 6], 1, false), Op::Call(306, vec![4, 7], 1, false), Op::Mul(8, 9)], ctrl: Ctrl::Return(6, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(4), Block { ops: vec![Op::Sub(3, 6), Op::EqZero(8)], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(9, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 10, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_307() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(3, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(6, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(307, vec![4, 7], 1, false)], ctrl: Ctrl::Return(5, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_308() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(3, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(6, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(308, vec![0, 7], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(308, vec![4, 7], 1, false)], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_309() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(309, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_310() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Store(vec![6, 0, 7])], ctrl: Ctrl::Return(0, vec![5, 8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(0, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 0, 1])], ctrl: Ctrl::Return(1, vec![6, 8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(3, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7, 1]) }), (G::from_u64(1), Block { ops: vec![Op::Call(310, vec![0, 4], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 3, 8])], ctrl: Ctrl::Return(3, vec![7, 10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 19, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_311() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![1, 2]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 7, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(1, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![1, 2]), Op::Store(vec![9, 10, 0])], ctrl: Ctrl::Return(1, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(6, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(311, vec![5, 1, 2], 1, false), Op::Store(vec![10, 4, 11])], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 2]), Op::Store(vec![11, 12, 5])], ctrl: Ctrl::Return(3, vec![13]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 26, lookups: 23 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_312() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 3)], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(2, 6)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(8, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Sub(9, 11)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Call(312, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![13]) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_313() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 2)], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(313, vec![3], 1, false), Op::U32LessThan(6, 5)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![6]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_314() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 3)], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(2, 6)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(8, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(314, vec![4, 1], 1, false), Op::Store(vec![13, 3, 14])], ctrl: Ctrl::Return(2, vec![15]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(10, 8)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(314, vec![0, 7], 1, false)], ctrl: Ctrl::Return(3, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(11, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(314, vec![4, 7], 1, false), Op::Store(vec![15, 3, 16])], ctrl: Ctrl::Return(4, vec![17]) }), (G::from_u64(0), Block { ops: vec![Op::Call(314, vec![4, 7], 1, false)], ctrl: Ctrl::Return(5, vec![15]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 31, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_315() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(316, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(316, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![3]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_316() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 2, 8]), Op::Store(vec![6, 9, 8])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(307, vec![1, 6], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 2, 8]), Op::Store(vec![11, 12, 5])], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Store(vec![1, 2, 12]), Op::Store(vec![10, 13, 0])], ctrl: Ctrl::Return(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![5, 1, 2], 1, false), Op::Store(vec![10, 4, 11])], ctrl: Ctrl::Return(4, vec![12]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 16, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_317() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![7, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![7, 12, 10])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(307, vec![1, 7], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(311, vec![9, 2, 3], 1, false), Op::Store(vec![7, 8, 12]), Op::Store(vec![11, 13, 6])], ctrl: Ctrl::Return(1, vec![14]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13]), Op::Store(vec![11, 12, 14]), Op::Store(vec![1, 11, 15]), Op::Store(vec![11, 16, 0])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(317, vec![6, 1, 2, 3], 1, false), Op::Store(vec![11, 5, 12])], ctrl: Ctrl::Return(3, vec![13]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 13, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_318() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(315, vec![3, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Call(318, vec![5, 1, 8, 3], 1, false)], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Call(318, vec![5, 1, 2, 3], 1, false), Op::Call(318, vec![6, 1, 2, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(3), Block { ops: vec![Op::Call(319, vec![5, 6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(310, vec![5, 1], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(315, vec![3, 1, 2], 1, false), Op::Call(317, vec![9, 8, 5, 2], 1, false)], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(317, vec![3, 1, 5, 2], 1, false)], ctrl: Ctrl::Return(6, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_319() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(315, vec![4, 2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 8), Op::Call(318, vec![0, 2, 3, 4], 1, false), Op::Call(318, vec![6, 2, 9, 10], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(319, vec![0, 6, 2, 3, 4], 1, false), Op::Call(319, vec![0, 7, 2, 3, 8], 1, false)], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Call(319, vec![0, 7, 2, 3, 4], 1, false), Op::Call(319, vec![6, 7, 2, 3, 8], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(4), Block { ops: vec![Op::Call(310, vec![6, 2], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(315, vec![4, 2, 3], 1, false), Op::Call(317, vec![10, 9, 6, 3], 1, false), Op::Call(318, vec![0, 9, 3, 11], 1, false)], ctrl: Ctrl::Return(4, vec![12]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(5, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(317, vec![4, 2, 6, 3], 1, false)], ctrl: Ctrl::Yield(6, vec![10]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(318, vec![0, 2, 3, 10], 1, false)], ctrl: Ctrl::Return(7, vec![11]) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_320() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(321, vec![3, 1], 1, false), Op::Call(320, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_321() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(308, vec![8, 5], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(321, vec![0, 4], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(309, vec![5, 8], 1, false)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(9, 6)], ctrl: Ctrl::Yield(4, vec![13]) })].into_iter().collect(), None, 1, 6, 6, Box::new(Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::MatchContinue(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(5, vec![17]) }), (G::from_u64(0), Block { ops: vec![Op::Call(313, vec![7], 1, false), Op::Const(G::from_u64(1)), Op::Add(17, 18), Op::U32LessThan(19, 6)], ctrl: Ctrl::Yield(6, vec![20]) })].into_iter().collect(), None, 1, 7, 7, Box::new(Block { ops: vec![Op::Mul(13, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(7, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(8, vec![6]) }))) })) })) })), 1, 21, 14, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(9, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(10, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(314, vec![7, 10], 1, false)], ctrl: Ctrl::Yield(11, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None, 1, 4, 2, Box::new(Block { ops: vec![Op::Store(vec![5, 13, 14]), Op::Call(321, vec![15, 4], 1, false)], ctrl: Ctrl::Return(12, vec![16]) })) })) }))) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 13, auxiliaries: 42, lookups: 24 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_322() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(322, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_323() -> Function { + Function { body: Block { ops: vec![Op::Call(322, vec![0], 1, false), Op::Call(322, vec![1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 8)], ctrl: Ctrl::Match(13, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(307, vec![10, 13], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Sub(11, 14)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Call(312, vec![12, 15], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Call(323, vec![6, 9], 1, false)], ctrl: Ctrl::Return(3, vec![19]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![19]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![17]) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 7, auxiliaries: 18, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_324() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(308, vec![6, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(324, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::MatchContinue(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(2, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(325, vec![8, 2], 1, false)], ctrl: Ctrl::Yield(3, vec![11]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(324, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(5, vec![12]) })].into_iter().collect(), None) })) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_325() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 3)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 7), Op::U32LessThan(8, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(325, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_326() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(308, vec![7, 1], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(326, vec![6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(327, vec![9, 2, 3], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(326, vec![6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![12]) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_327() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(6, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(327, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(327, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_328() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(324, vec![1, 5, 6], 1, false)], ctrl: Ctrl::Yield(2, vec![8]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Call(329, vec![7, 1, 5], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(328, vec![4, 1], 1, false)], ctrl: Ctrl::Return(5, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_329() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(326, vec![1, 2, 6, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Call(329, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![9]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_330() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Store(vec![3, 1, 3]), Op::Store(vec![1, 4, 3]), Op::Call(318, vec![0, 3, 1, 5], 1, false), Op::Call(320, vec![6, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_331() -> Function { + Function { body: Block { ops: vec![Op::Call(306, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(330, vec![0], 1, false), Op::Call(330, vec![1], 1, false), Op::Call(328, vec![6, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_332() -> Function { + Function { body: Block { ops: vec![Op::Call(306, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Call(330, vec![0], 1, false), Op::Call(330, vec![1], 1, false), Op::Call(323, vec![3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_333() -> Function { + Function { body: Block { ops: vec![Op::Call(338, vec![0], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(338, vec![1], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::U32LessThan(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(334, vec![0, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(334, vec![0, 1], 1, false)], ctrl: Ctrl::Return(3, vec![4]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 11, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_334() -> Function { + Function { body: Block { ops: vec![Op::Call(335, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(336, vec![1, 0], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(336, vec![0, 1], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(337, vec![0, 1], 1, false)], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 13, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_335() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![9]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(335, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(335, vec![4, 7], 1, false), Op::Call(335, vec![5, 8], 1, false), Op::Mul(9, 10)], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![9]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(3), Block { ops: vec![Op::Call(335, vec![4, 7], 1, false), Op::Call(335, vec![5, 8], 1, false), Op::Mul(9, 10)], ctrl: Ctrl::Return(7, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![9]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(4), Block { ops: vec![Op::Sub(4, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![9]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 12, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_336() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(335, vec![3, 1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(335, vec![4, 1], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![5]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_337() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(339, vec![0, 2], 2, false), Op::Call(339, vec![1, 2], 2, false), Op::Call(335, vec![3, 5], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::U32LessThan(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Store(vec![8, 0, 1])], ctrl: Ctrl::Return(2, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 12, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_338() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 5]) }), (G::from_u64(1), Block { ops: vec![Op::Call(338, vec![2], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 6)], ctrl: Ctrl::Return(1, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![6, 6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![4, 4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_339() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 5), Op::Call(339, vec![3, 6], 2, false)], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 1]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_340() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Call(333, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(305, vec![1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(333, vec![0, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(306, vec![0, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Store(vec![10, 0, 1])], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_341() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![4, 2, 5])], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(341, vec![2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 6])], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(341, vec![2], 1, false), Op::Call(341, vec![3], 1, false), Op::Call(333, vec![4, 5], 1, false)], ctrl: Ctrl::Return(3, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(341, vec![2], 1, false), Op::Call(341, vec![3], 1, false), Op::Call(340, vec![4, 5], 1, false)], ctrl: Ctrl::Return(4, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_342() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(342, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(342, vec![3, 1], 1, false), Op::Call(342, vec![4, 1], 1, false), Op::Call(333, vec![5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(342, vec![3, 1], 1, false), Op::Call(342, vec![4, 1], 1, false), Op::Call(340, vec![5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(789, vec![1, 3], 1, false)], ctrl: Ctrl::Return(4, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_343() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(342, vec![3, 1], 1, false), Op::Call(343, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_344() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(345, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_345() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(342, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(343, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 7, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(344, vec![3, 1], 1, false), Op::Call(344, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(3, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(344, vec![3, 1], 1, false), Op::Call(344, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(344, vec![3, 1], 1, false), Op::Call(344, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(5, vec![10]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(344, vec![3, 1], 1, false), Op::Call(344, vec![4, 1], 1, false), Op::Call(344, vec![5, 1], 1, false), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(6, vec![10]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 4, 7])], ctrl: Ctrl::Return(7, vec![8]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(344, vec![5, 1], 1, false), Op::Store(vec![6, 3, 4, 7])], ctrl: Ctrl::Return(8, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_346() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![22]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Call(15, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Call(346, vec![11, 21], 1, false)], ctrl: Ctrl::Return(3, vec![23]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![23]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_347() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(347, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_348() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(346, vec![1, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(347, vec![1, 3], 1, false)], ctrl: Ctrl::Return(2, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![4]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_349() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 5)], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![5]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![5]) }), (G::from_u64(3), Block { ops: vec![Op::Call(349, vec![2], 1, false), Op::Call(349, vec![3], 1, false), Op::Call(351, vec![5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(349, vec![2], 1, false), Op::Call(349, vec![3], 1, false), Op::Call(352, vec![6], 1, false), Op::Call(351, vec![5, 7], 1, false)], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(5), Block { ops: vec![Op::Call(349, vec![2], 1, false), Op::Call(349, vec![3], 1, false), Op::Call(352, vec![6], 1, false), Op::Call(351, vec![5, 7], 1, false)], ctrl: Ctrl::Return(6, vec![8]) }), (G::from_u64(6), Block { ops: vec![Op::Call(350, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Return(7, vec![5]) }), (G::from_u64(8), Block { ops: vec![Op::Call(349, vec![4], 1, false)], ctrl: Ctrl::Return(8, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_350() -> Function { + Function { body: Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(349, vec![1], 1, false), Op::Call(351, vec![3, 4], 1, false), Op::Call(349, vec![2], 1, false), Op::Call(352, vec![6], 1, false), Op::Call(351, vec![5, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_351() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_352() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 1)], ctrl: Ctrl::Return(1, vec![2]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_353() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_354() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 2)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(354, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(354, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![Op::Call(355, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(7, vec![7]) }), (G::from_u64(5), Block { ops: vec![Op::Call(355, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(8, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Call(356, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(9, vec![7]) }), (G::from_u64(8), Block { ops: vec![Op::Call(354, vec![6, 1, 2], 1, false)], ctrl: Ctrl::Return(10, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 17, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_355() -> Function { + Function { body: Block { ops: vec![Op::Call(354, vec![0, 2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 5), Op::Add(3, 5), Op::Call(354, vec![1, 6, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_356() -> Function { + Function { body: Block { ops: vec![Op::Call(354, vec![0, 3, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(354, vec![1, 3, 4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Add(4, 7), Op::Call(354, vec![2, 8, 9], 1, false)], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_357() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Call(353, vec![1, 2], 1, false), Op::Call(358, vec![0, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_358() -> Function { + Function { body: Block { ops: vec![Op::Call(359, vec![0], 1, false), Op::U32LessThan(2, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(798, vec![0, 2], 1, false), Op::Sub(1, 2), Op::Call(358, vec![4, 5], 1, false), Op::Add(2, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_359() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(349, vec![2], 1, false), Op::Call(360, vec![3, 5], 1, false), Op::Add(4, 6)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_360() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(359, vec![0], 1, false), Op::U32LessThan(2, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(798, vec![0, 2], 1, false), Op::Sub(1, 2), Op::Call(360, vec![4, 5], 1, false), Op::Add(2, 6)], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_361() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Call(353, vec![1, 4], 1, false), Op::Call(358, vec![0, 5], 1, false), Op::Call(797, vec![0, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 13, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_362() -> Function { + Function { body: Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Call(0, vec![2, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(363, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_363() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(0, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(2, vec![6]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(3, vec![6]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(4, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(362, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(362, vec![4, 1], 1, false), Op::Call(353, vec![6, 7], 1, false)], ctrl: Ctrl::Return(6, vec![8]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(364, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(7, vec![6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(364, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(8, vec![6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(365, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(9, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(362, vec![5, 1], 1, false)], ctrl: Ctrl::Return(10, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_364() -> Function { + Function { body: Block { ops: vec![Op::Call(362, vec![0, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 4), Op::Call(362, vec![1, 5], 1, false), Op::Call(353, vec![3, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_365() -> Function { + Function { body: Block { ops: vec![Op::Call(362, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(362, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(353, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Call(362, vec![2, 8], 1, false), Op::Call(353, vec![6, 9], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_366() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(0, vec![2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(367, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![5]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_367() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(368, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(366, vec![4, 1, 2], 1, false), Op::Call(366, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(366, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(366, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(366, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(366, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Call(369, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(7, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(366, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_368() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 0, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Add(0, 1), Op::Store(vec![4, 5, 4, 4])], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_369() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(366, vec![0, 3, 4], 1, false), Op::Call(366, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(366, vec![2, 3, 9], 1, false), Op::Store(vec![5, 6, 7, 10])], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_370() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(0, vec![2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(371, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![5]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_371() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(4, 1), Op::Store(vec![8, 9, 8, 8])], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(370, vec![4, 1, 2], 1, false), Op::Call(370, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(4, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(370, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(370, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(370, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(370, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(6, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(370, vec![4, 1, 2], 1, false), Op::Call(370, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 10), Op::Call(370, vec![6, 1, 11], 1, false), Op::Store(vec![7, 8, 9, 12])], ctrl: Ctrl::Return(7, vec![13]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(370, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(9, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_372() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(372, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(372, vec![4, 1], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(373, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(373, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(5, vec![6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(374, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(372, vec![5, 1], 1, false)], ctrl: Ctrl::Return(7, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_373() -> Function { + Function { body: Block { ops: vec![Op::Call(372, vec![0, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 4), Op::Call(372, vec![1, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_374() -> Function { + Function { body: Block { ops: vec![Op::Call(372, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(372, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 6), Op::Call(372, vec![2, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_375() -> Function { + Function { body: Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(0, vec![2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(372, vec![0, 2], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(376, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 6), Op::Call(370, vec![0, 6, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_376() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(377, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(375, vec![4, 1, 2], 1, false), Op::Call(375, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(375, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(375, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(375, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(375, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Call(378, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(7, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(375, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_377() -> Function { + Function { body: Block { ops: vec![Op::Call(0, vec![0, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 0, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(0, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(366, vec![1, 2, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(0, 6), Op::Store(vec![5, 7, 5, 5])], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_378() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(375, vec![0, 3, 4], 1, false), Op::Call(375, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(375, vec![2, 3, 9], 1, false), Op::Store(vec![5, 6, 7, 10])], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_379() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![1], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(0, vec![2, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Add(2, 3), Op::Call(354, vec![0, 2, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(381, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(2, 3), Op::Call(370, vec![0, 3, 8], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_380() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::Sub(0, 2), Op::Call(0, vec![4, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(789, vec![1, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(366, vec![6, 2, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(0, 3), Op::Store(vec![6, 7, 6, 6])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_381() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(380, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(379, vec![4, 1, 2], 1, false), Op::Call(379, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(379, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(379, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(379, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(379, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Call(382, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(7, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(379, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_382() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(379, vec![0, 3, 4], 1, false), Op::Call(379, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(379, vec![2, 3, 9], 1, false), Op::Store(vec![5, 6, 7, 10])], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_383() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 2]), Op::Call(383, vec![5, 9, 11], 3, false)], ctrl: Ctrl::Return(0, vec![12, 13, 14]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 2, 1]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 2, 1]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_384() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(383, vec![1, 0, 4], 3, false), Op::Call(787, vec![6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(263, vec![1, 0], 1, false)], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![6, 9], 1, false), Op::Call(375, vec![5, 10, 9], 1, false), Op::Call(385, vec![11, 7, 2], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(379, vec![5, 6, 9], 1, false), Op::Call(385, vec![10, 7, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_385() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(786, vec![8, 1], 1, false), Op::Call(385, vec![7, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(384, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(404, vec![4, 5, 0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![6, 5, 7], 1, false), Op::Call(385, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Call(386, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![0, 1], 1, false)], ctrl: Ctrl::Return(5, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_386() -> Function { + Function { body: Block { ops: vec![Op::Call(425, vec![2, 4], 1, false), Op::Call(239, vec![5, 4], 1, false), Op::Call(122, vec![6], 2, false), Op::Call(393, vec![0, 1, 7, 8], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(385, vec![10, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 7)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(394, vec![7], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(6), Block { ops: vec![Op::Add(22, 1), Op::Call(789, vec![8, 28], 1, false), Op::Call(385, vec![29, 3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![28, 0, 1, 5]), Op::Call(263, vec![29, 3], 1, false)], ctrl: Ctrl::Return(2, vec![30]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![15, 0, 1, 5]), Op::Call(263, vec![16, 3], 1, false)], ctrl: Ctrl::Return(3, vec![17]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 28, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_387() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(61)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(239)), Op::Store(vec![0, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 11, 26, 27, 14, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_388() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(22)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(133)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 5, 15, 16, 17, 18, 19, 20, 4, 21, 22, 23, 22, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_389() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(53)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(188)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 6, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 17, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_390() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(129)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(169)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 5, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_391() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(134)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(33)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 29])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_392() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(23)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(239)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 8, 10, 18, 6, 19, 20, 21, 17, 22, 23, 24, 24, 25, 26])], ctrl: Ctrl::Return(0, vec![27]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_393() -> Function { + Function { body: Block { ops: vec![Op::Call(387, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(388, vec![], 1, false), Op::Call(2, vec![7, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![3], 1, false), Op::Const(G::from_u64(5)), Op::U32LessThan(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![3, 15], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![3, 17], 1, false), Op::Const(G::from_u64(2)), Op::Call(789, vec![3, 19], 1, false), Op::Const(G::from_u64(3)), Op::Call(789, vec![3, 21], 1, false), Op::Const(G::from_u64(4)), Op::Call(789, vec![3, 23], 1, false), Op::Load(4, 18)], ctrl: Ctrl::Match(25, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 20)], ctrl: Ctrl::Match(29, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![33, 0, 1, 31]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![35, 30, 34, 36]), Op::Load(4, 22)], ctrl: Ctrl::Match(38, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![42, 0, 1, 40]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![44, 39, 43, 45]), Op::Const(G::from_u64(2)), Op::Call(389, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49]), Op::Store(vec![47, 48, 50, 45]), Op::Store(vec![44, 26, 51, 45]), Op::Store(vec![47, 7, 8, 45]), Op::Const(G::from_u64(3)), Op::Store(vec![54, 53, 16, 45]), Op::Store(vec![54, 55, 52, 45]), Op::Store(vec![54, 56, 37, 45]), Op::Store(vec![54, 57, 46, 45]), Op::Store(vec![54, 58, 24, 45]), Op::Const(G::from_u64(5)), Op::Call(798, vec![3, 60], 1, false), Op::Call(263, vec![59, 61], 1, false)], ctrl: Ctrl::Return(3, vec![49, 62]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![42, 42, 42, 42])], ctrl: Ctrl::Return(4, vec![42, 43]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![33, 33, 33, 33])], ctrl: Ctrl::Return(5, vec![33, 34]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![29, 29, 29, 29])], ctrl: Ctrl::Return(6, vec![29, 30]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(7, vec![10, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(8, vec![6, 7]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 52, lookups: 37 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_394() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![Op::Call(295, vec![2], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![6, 7, 5, 5]), Op::Store(vec![5, 5, 8, 5, 5, 5, 5, 5, 5, 5, 5, 5])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_395() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(425, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Call(395, vec![4, 1], 1, false), Op::Store(vec![6, 5, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_396() -> Function { + Function { body: Block { ops: vec![Op::Call(395, vec![1, 2], 1, false), Op::Call(787, vec![3], 1, false), Op::Call(157, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false), Op::Call(156, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(0, vec![11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![3, 11], 1, false), Op::Call(251, vec![12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(798, vec![3, 15], 1, false), Op::Call(123, vec![14], 1, false), Op::Call(253, vec![17], 1, false), Op::Call(263, vec![18, 16], 1, false)], ctrl: Ctrl::Return(1, vec![15, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(3, vec![11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![3, 11], 1, false), Op::Call(251, vec![12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(798, vec![3, 15], 1, false), Op::Call(133, vec![14], 1, false), Op::Call(130, vec![17], 1, false), Op::Call(253, vec![18], 1, false), Op::Call(263, vec![19, 16], 1, false)], ctrl: Ctrl::Return(4, vec![15, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(5, vec![15, 16]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(272, vec![0, 3, 4], 2, false)], ctrl: Ctrl::Return(6, vec![9, 10]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 23, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_397() -> Function { + Function { body: Block { ops: vec![Op::Call(395, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Call(122, vec![7], 2, false), Op::Call(395, vec![10, 1], 1, false), Op::Call(263, vec![9, 11], 1, false), Op::Call(425, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 12, 8]), Op::Store(vec![14, 13, 15])], ctrl: Ctrl::Return(2, vec![16]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 15, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_398() -> Function { + Function { body: Block { ops: vec![Op::Call(156, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(157, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(170, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(171, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(172, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(175, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(6, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(7, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(174, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(8, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(182, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(9, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(183, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(10, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(11, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(178, vec![], 1, false), Op::Call(2, vec![0, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(12, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![], 1, false), Op::Call(2, vec![0, 27], 1, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(13, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![], 1, false), Op::Call(2, vec![0, 29], 1, false)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(14, vec![31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(181, vec![], 1, false), Op::Call(2, vec![0, 31], 1, false)], ctrl: Ctrl::Match(32, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(15, vec![33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(16, vec![33]) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) })), 1, 46, 30, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(227, vec![0], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(18, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(205, vec![0], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(19, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(192, vec![0], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(20, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(533, vec![0], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(21, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(250, vec![0], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(22, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(23, vec![9]) }))) }))) }))) }))) }))) }))) })) }, layout: FunctionLayout { input_size: 1, selectors: 24, auxiliaries: 61, lookups: 38 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_399() -> Function { + Function { body: Block { ops: vec![Op::Call(398, vec![0], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(396, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(0, vec![5, 6]) }), (G::from_u64(2), Block { ops: vec![Op::Call(395, vec![2, 3], 1, false), Op::Call(228, vec![0, 5, 3], 2, false)], ctrl: Ctrl::Return(1, vec![6, 7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(211, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(2, vec![5, 6]) }), (G::from_u64(4), Block { ops: vec![Op::Call(195, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(3, vec![5, 6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(539, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(4, vec![5, 6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(261, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(5, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(6, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_400() -> Function { + Function { body: Block { ops: vec![Op::Call(391, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(401, vec![1, 2], 2, false)], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(392, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(402, vec![1, 2], 2, false)], ctrl: Ctrl::Return(1, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(2, vec![7, 8]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_401() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(6)), Op::U32LessThan(2, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(789, vec![0, 5], 1, false), Op::Const(G::from_u64(5)), Op::Call(789, vec![0, 7], 1, false), Op::Call(403, vec![8, 1], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(798, vec![0, 11], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![14, 6, 10, 15]), Op::Call(263, vec![16, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 16, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_402() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(5)), Op::U32LessThan(2, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(789, vec![0, 5], 1, false), Op::Const(G::from_u64(4)), Op::Call(789, vec![0, 7], 1, false), Op::Call(403, vec![8, 1], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(798, vec![0, 11], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![14, 6, 10, 15]), Op::Call(263, vec![16, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 16, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_403() -> Function { + Function { body: Block { ops: vec![Op::Call(425, vec![0, 1], 1, false), Op::Call(122, vec![2], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(390, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![4], 1, false), Op::Const(G::from_u64(3)), Op::Sub(11, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(789, vec![4, 15], 1, false)], ctrl: Ctrl::Return(0, vec![14, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(1, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(3, vec![9, 10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 13, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_404() -> Function { + Function { body: Block { ops: vec![Op::Call(399, vec![0, 1, 3, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(425, vec![6, 4], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(405, vec![11, 3], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(425, vec![21, 4], 1, false)], ctrl: Ctrl::Return(2, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(344, vec![11, 1], 1, false), Op::Call(385, vec![22, 3, 4], 1, false)], ctrl: Ctrl::Return(3, vec![23]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(4, vec![20]) }), (G::from_u64(4), Block { ops: vec![Op::Call(400, vec![0, 3, 4], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(425, vec![21, 4], 1, false)], ctrl: Ctrl::Return(5, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(6, vec![22]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Add(11, 13), Op::Add(20, 14), Op::Add(21, 12)], ctrl: Ctrl::MatchContinue(16, [(G::from_u64(1), Block { ops: vec![Op::Call(416, vec![10, 22], 2, false), Op::Call(408, vec![1, 3, 11, 13, 14, 12, 15, 24, 4], 2, false)], ctrl: Ctrl::Yield(7, vec![25, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(8, vec![23, 2]) })), 2, 4, 2, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(9, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(642, vec![10, 11, 13, 14, 12], 1, false), Op::Call(412, vec![1, 3, 11, 13, 14, 12, 15, 4, 2, 25], 2, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Call(425, vec![27, 4], 1, false)], ctrl: Ctrl::Return(10, vec![28]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(11, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(415, vec![10, 1, 3, 11, 13, 14, 12, 15, 4], 2, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Call(425, vec![29, 4], 1, false)], ctrl: Ctrl::Return(12, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(13, vec![27]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(14, vec![28]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(15, vec![20]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 32, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_405() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(406, vec![0, 2], 5, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::U32LessThan(8, 4)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(789, vec![1, 7], 1, false), Op::Const(G::from_u64(8)), Op::Store(vec![11, 5, 6, 10]), Op::Call(798, vec![1, 4], 1, false), Op::Const(G::from_u64(1)), Op::Call(263, vec![12, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Return(2, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 18, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_406() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(406, vec![4, 7], 5, false)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11, 12]) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Sub(12, 7)], ctrl: Ctrl::Return(1, vec![11, 1, 3, 4, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 11, 12, 11, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 10, 11, 10, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(4, vec![6, 6, 7, 6, 6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 17, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_407() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(141, vec![3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(155, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 9, 10])], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(133, vec![3], 1, false), Op::Call(130, vec![6], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 7, 9]), Op::Const(G::from_u64(2)), Op::Call(156, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13]), Op::Store(vec![11, 12, 14, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![16, 15, 10, 9])], ctrl: Ctrl::Return(1, vec![17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 14, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_408() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 6)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(4, 5), Op::Add(3, 14), Op::Add(2, 15), Op::Call(787, vec![1], 1, false), Op::Call(0, vec![16, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(0, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(789, vec![1, 16], 1, false), Op::Call(409, vec![19, 10, 2, 7, 8], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![21, 21, 21, 21])], ctrl: Ctrl::Return(1, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(344, vec![12, 0], 1, false), Op::Add(3, 4), Op::Add(2, 22), Op::Call(797, vec![1, 23], 1, false), Op::Const(G::from_u64(1)), Op::Add(16, 25), Op::Call(798, vec![1, 26], 1, false), Op::Call(263, vec![21, 24], 1, false), Op::Call(263, vec![28, 27], 1, false), Op::Call(425, vec![29, 8], 1, false)], ctrl: Ctrl::Return(2, vec![25, 30]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 18, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_409() -> Function { + Function { body: Block { ops: vec![Op::Call(495, vec![0, 4], 1, false), Op::Call(425, vec![5, 4], 1, false), Op::Call(122, vec![6], 2, false), Op::Load(4, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![10, 3], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![10], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(573, vec![22, 23, 1], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![28, 27, 11, 29]), Op::Call(797, vec![8, 2], 1, false), Op::Call(263, vec![30, 31], 1, false), Op::Call(495, vec![32, 4], 1, false), Op::Call(446, vec![6, 33, 4], 1, false)], ctrl: Ctrl::Return(1, vec![34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![27]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![13]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 30, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_410() -> Function { + Function { body: Block { ops: vec![Op::Call(797, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 4), Op::Call(798, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4]), Op::Store(vec![7, 2, 8]), Op::Call(786, vec![3, 9], 1, false), Op::Call(786, vec![10, 6], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_411() -> Function { + Function { body: Block { ops: vec![Op::Call(425, vec![0, 1], 1, false), Op::Call(122, vec![2], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(295, vec![6], 1, false), Op::Load(12, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(344, vec![13, 7], 1, false), Op::Call(385, vec![22, 4, 1], 1, false), Op::Call(411, vec![23, 1], 1, false)], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 24, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_412() -> Function { + Function { body: Block { ops: vec![Op::Add(4, 5), Op::Add(3, 10), Op::Add(2, 11), Op::Call(787, vec![1], 1, false), Op::U32LessThan(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(270, vec![1, 2, 3, 4, 12], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![17, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(789, vec![1, 12], 1, false), Op::Call(267, vec![17], 1, false), Op::Call(411, vec![18, 7], 1, false), Op::Call(267, vec![19], 1, false), Op::Call(407, vec![20], 1, false), Op::Call(413, vec![21], 4, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Call(2, vec![24, 9], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![26], vec![27], Some("iota: major's constructor belongs to a different inductive".into())), Op::Call(414, vec![6, 23], 3, false)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Call(410, vec![1, 12, 19], 1, false), Op::Const(G::from_u64(2)), Op::Call(263, vec![8, 31], 1, false)], ctrl: Ctrl::Return(2, vec![32, 33]) }), (G::from_u64(1), Block { ops: vec![Op::Call(344, vec![30, 0], 1, false), Op::Add(3, 4), Op::Add(2, 32), Op::Call(797, vec![1, 33], 1, false), Op::Call(787, vec![25], 1, false), Op::Sub(35, 29), Op::Call(798, vec![25, 36], 1, false), Op::Const(G::from_u64(1)), Op::Add(12, 38), Op::Call(798, vec![1, 39], 1, false), Op::Call(263, vec![31, 34], 1, false), Op::Call(263, vec![41, 37], 1, false), Op::Call(263, vec![42, 40], 1, false)], ctrl: Ctrl::Return(3, vec![38, 43]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(410, vec![1, 12, 19], 1, false), Op::Const(G::from_u64(2)), Op::Call(263, vec![8, 26], 1, false)], ctrl: Ctrl::Return(4, vec![27, 28]) }))) }))) }))) }, layout: FunctionLayout { input_size: 10, selectors: 5, auxiliaries: 33, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_413() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(295, vec![4], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(471, vec![11, 12], 1, false)], ctrl: Ctrl::Return(0, vec![20, 13, 21, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22])], ctrl: Ctrl::Return(1, vec![20, 20, 21, 23]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9])], ctrl: Ctrl::Return(2, vec![7, 7, 8, 10]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 23, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_414() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 7, 8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8, 4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(414, vec![6, 1], 3, false)], ctrl: Ctrl::Return(2, vec![8, 9, 10]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 10, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_415() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(0, vec![14, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Load(5, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(1, vec![19, 20]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(3, 4), Op::Add(19, 5), Op::Add(20, 6), Op::Call(416, vec![0, 21], 2, false)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![24, 24, 24, 24])], ctrl: Ctrl::Return(2, vec![24, 25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![23], 1, false), Op::Load(12, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(30, 37)], ctrl: Ctrl::Match(38, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(29, [(G::from_u64(0), Block { ops: vec![Op::Call(418, vec![23], 1, false)], ctrl: Ctrl::Match(39, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![40, 40, 40, 40])], ctrl: Ctrl::Return(3, vec![40, 41]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(789, vec![2, 21], 1, false), Op::Call(787, vec![8], 1, false), Op::Call(349, vec![40], 1, false), Op::Call(0, vec![41, 42], 1, false)], ctrl: Ctrl::Match(43, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![44, 44, 44, 44])], ctrl: Ctrl::Return(4, vec![44, 45]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(495, vec![40, 8], 1, false), Op::Call(477, vec![44, 8], 1, false)], ctrl: Ctrl::Match(45, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![46, 46, 46, 46])], ctrl: Ctrl::Return(5, vec![46, 47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(344, vec![12, 1], 1, false), Op::Add(3, 4), Op::Add(47, 5), Op::Call(797, vec![2, 48], 1, false), Op::Call(263, vec![46, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(417, vec![50, 23, 40, 11, 51], 1, false), Op::Const(G::from_u64(1)), Op::Add(21, 53), Op::Call(798, vec![2, 54], 1, false), Op::Call(263, vec![52, 55], 1, false)], ctrl: Ctrl::Return(6, vec![53, 56]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![39, 39, 39, 39])], ctrl: Ctrl::Return(7, vec![39, 40]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![39, 39, 39, 39])], ctrl: Ctrl::Return(8, vec![39, 40]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![37, 37, 37, 37])], ctrl: Ctrl::Return(9, vec![37, 38]) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 10, auxiliaries: 43, lookups: 19 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_416() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(122, vec![3], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(2, vec![6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(416, vec![4, 7], 2, false)], ctrl: Ctrl::Return(3, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(4, vec![6, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 13, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_417() -> Function { + Function { body: Block { ops: vec![Op::Sub(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![6, 1, 4, 2]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![8, 0, 7, 9]), Op::Const(G::from_u64(1)), Op::Add(4, 11), Op::Call(417, vec![10, 1, 2, 3, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_418() -> Function { + Function { body: Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(419, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(420, vec![9, 10, 7, 5, 14, 15], 1, false)], ctrl: Ctrl::Return(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 16, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_419() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![1], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Call(303, vec![3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![50]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51]), Op::Store(vec![50, 0, 52])], ctrl: Ctrl::Return(1, vec![53]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_420() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0, 1, 5], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(6), Block { ops: vec![Op::Call(421, vec![10, 3], 1, false), Op::Call(422, vec![20, 4], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 22), Op::Call(420, vec![0, 1, 2, 3, 4, 23], 1, false)], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![20]) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 19, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_421() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(421, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_422() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(423, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(422, vec![4, 1], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_423() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(424, vec![3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(423, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(423, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(423, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(423, vec![4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Call(423, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(423, vec![4, 1], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Call(423, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(423, vec![4, 1], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(423, vec![5, 1], 1, false)], ctrl: Ctrl::Return(9, vec![8]) }))) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(423, vec![5, 1], 1, false)], ctrl: Ctrl::Return(10, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 12, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_424() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(424, vec![0, 4], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_425() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(361, vec![1, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Call(385, vec![0, 9, 7], 1, false)], ctrl: Ctrl::Return(5, vec![10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_426() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(385, vec![0, 3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_427() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(349, vec![0], 1, false), Op::Call(361, vec![1, 8], 1, false), Op::Call(428, vec![0, 7, 9], 1, false)], ctrl: Ctrl::Return(5, vec![10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_428() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(786, vec![8, 1], 1, false), Op::Call(428, vec![7, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(383, vec![0, 1, 8], 3, false), Op::Call(787, vec![10], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(263, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![10, 13], 1, false), Op::Call(375, vec![9, 14, 13], 1, false), Op::Call(428, vec![15, 11, 2], 1, false)], ctrl: Ctrl::Return(2, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(379, vec![9, 10, 13], 1, false), Op::Call(428, vec![14, 11, 2], 1, false)], ctrl: Ctrl::Return(3, vec![15]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![6, 5, 7], 1, false), Op::Call(428, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Call(429, vec![4, 5, 6, 1, 2, 0], 1, false)], ctrl: Ctrl::Return(5, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(430, vec![4, 5, 0, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![0, 1], 1, false)], ctrl: Ctrl::Return(7, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_429() -> Function { + Function { body: Block { ops: vec![Op::Call(427, vec![2, 4], 1, false), Op::Call(122, vec![6], 2, false), Op::Load(4, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(394, vec![7], 1, false), Op::Load(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(6), Block { ops: vec![Op::Add(20, 1), Op::Call(789, vec![8, 26], 1, false), Op::Call(428, vec![27, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![5, 3], 1, false)], ctrl: Ctrl::Return(1, vec![26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![5, 3], 1, false)], ctrl: Ctrl::Return(2, vec![13]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 23, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_430() -> Function { + Function { body: Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(7), Block { ops: vec![Op::Call(642, vec![8, 9, 11, 12, 10], 1, false), Op::Call(412, vec![1, 3, 9, 11, 12, 10, 13, 4, 2, 18], 2, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Call(427, vec![20, 4], 1, false)], ctrl: Ctrl::Return(0, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 19, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_431() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(361, vec![1, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Call(433, vec![0, 9, 7], 1, false)], ctrl: Ctrl::Return(5, vec![10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_432() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(433, vec![0, 3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_433() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(786, vec![8, 1], 1, false), Op::Call(433, vec![7, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(434, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(436, vec![4, 5, 0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![6, 5, 7], 1, false), Op::Call(433, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Call(435, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![0, 1], 1, false)], ctrl: Ctrl::Return(5, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_434() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(383, vec![1, 0, 4], 3, false), Op::Call(787, vec![6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(263, vec![1, 0], 1, false)], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![6, 9], 1, false), Op::Call(375, vec![5, 10, 9], 1, false), Op::Call(433, vec![11, 7, 2], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(379, vec![5, 6, 9], 1, false), Op::Call(433, vec![10, 7, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_435() -> Function { + Function { body: Block { ops: vec![Op::Call(431, vec![2, 4], 1, false), Op::Call(239, vec![5, 4], 1, false), Op::Call(122, vec![6], 2, false), Op::Call(393, vec![0, 1, 7, 8], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(433, vec![10, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 7)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(394, vec![7], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(6), Block { ops: vec![Op::Add(22, 1), Op::Call(789, vec![8, 28], 1, false), Op::Call(433, vec![29, 3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![28, 0, 1, 5]), Op::Call(263, vec![29, 3], 1, false)], ctrl: Ctrl::Return(2, vec![30]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![15, 0, 1, 5]), Op::Call(263, vec![16, 3], 1, false)], ctrl: Ctrl::Return(3, vec![17]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 28, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_436() -> Function { + Function { body: Block { ops: vec![Op::Call(398, vec![0], 1, false)], ctrl: Ctrl::MatchContinue(5, [(G::from_u64(1), Block { ops: vec![Op::Call(263, vec![2, 3], 1, false), Op::Call(349, vec![6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(399, vec![0, 1, 3, 4], 2, false)], ctrl: Ctrl::Yield(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Yield(1, vec![8, 9]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(399, vec![0, 1, 3, 4], 2, false)], ctrl: Ctrl::Yield(2, vec![6, 7]) })), 2, 4, 3, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![7, 4], 1, false)], ctrl: Ctrl::Return(3, vec![8]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(405, vec![12, 3], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![22, 4], 1, false)], ctrl: Ctrl::Return(5, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(6, vec![23]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(400, vec![0, 3, 4], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![22, 4], 1, false)], ctrl: Ctrl::Return(7, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(8, vec![23]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Add(12, 14), Op::Add(21, 15), Op::Add(22, 13)], ctrl: Ctrl::MatchContinue(17, [(G::from_u64(1), Block { ops: vec![Op::Call(416, vec![11, 23], 2, false), Op::Call(408, vec![1, 3, 12, 14, 15, 13, 16, 25, 4], 2, false)], ctrl: Ctrl::Yield(9, vec![26, 27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![24, 2]) })), 2, 4, 2, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(11, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(642, vec![11, 12, 14, 15, 13], 1, false), Op::Call(412, vec![1, 3, 12, 14, 15, 13, 16, 4, 2, 26], 2, false)], ctrl: Ctrl::Match(27, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![28, 4], 1, false)], ctrl: Ctrl::Return(12, vec![29]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(13, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(415, vec![11, 1, 3, 12, 14, 15, 13, 16, 4], 2, false)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![30, 4], 1, false)], ctrl: Ctrl::Return(14, vec![31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(15, vec![28]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(16, vec![29]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(263, vec![2, 3], 1, false)], ctrl: Ctrl::Return(17, vec![21]) }))) }))) })) }, layout: FunctionLayout { input_size: 5, selectors: 18, auxiliaries: 37, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_437() -> Function { + Function { body: Block { ops: vec![Op::Call(789, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Const(G::from_u64(0)), Op::Call(366, vec![2, 4, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_438() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 8, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_439() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![2]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![2]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![2]) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Return(6, vec![2]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 8, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_440() -> Function { + Function { body: Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(361, vec![1, 2], 1, false), Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(789, vec![3, 5], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 9), Op::Const(G::from_u64(0)), Op::Call(366, vec![8, 10, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 9]), Op::Call(341, vec![10], 1, false), Op::Store(vec![8, 11, 9, 9])], ctrl: Ctrl::Return(1, vec![12]) }), (G::from_u64(2), Block { ops: vec![Op::Call(295, vec![5], 1, false), Op::Load(12, 8), Op::Call(438, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(787, vec![6], 1, false), Op::AssertEq(vec![22], vec![21], Some("Const applied to wrong number of universe levels".into())), Op::Call(439, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(344, vec![23, 6], 1, false)], ctrl: Ctrl::Return(2, vec![24]) }), (G::from_u64(3), Block { ops: vec![Op::Call(440, vec![5, 3], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![11, 6, 13], 1, false)], ctrl: Ctrl::Return(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(425, vec![8, 3], 1, false), Op::Load(4, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![16, 6, 18], 1, false)], ctrl: Ctrl::Return(4, vec![19]) })].into_iter().collect(), None) }))) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 3]), Op::Call(440, vec![6, 9], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![11, 5, 10, 8])], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(5), Block { ops: vec![Op::Call(442, vec![5, 3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 5, 3]), Op::Call(442, vec![6, 10], 1, false), Op::Const(G::from_u64(1)), Op::Call(340, vec![8, 11], 1, false), Op::Store(vec![12, 13, 9, 9])], ctrl: Ctrl::Return(6, vec![14]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![7, 6, 8], 1, false), Op::Call(440, vec![9, 3], 1, false)], ctrl: Ctrl::Return(7, vec![10]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(389, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 11, 12])], ctrl: Ctrl::Return(8, vec![13]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(226, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 11, 12])], ctrl: Ctrl::Return(9, vec![13]) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![Op::Call(440, vec![7, 3], 1, false), Op::Call(425, vec![8, 3], 1, false), Op::Call(122, vec![9], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![13], vec![5], Some("projection's structure type differs from the value's head".into())), Op::Call(295, vec![13], 1, false), Op::Load(12, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![22], vec![29], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(298, vec![24, 25, 30], 1, false), Op::Load(12, 31)], ctrl: Ctrl::Match(32, [(G::from_u64(6), Block { ops: vec![Op::Call(344, vec![34, 14], 1, false), Op::Call(443, vec![44, 11, 20], 1, false), Op::Const(G::from_u64(0)), Op::Call(444, vec![45, 6, 46, 5, 7], 1, false)], ctrl: Ctrl::Return(10, vec![47]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 44, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_441() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(789, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Const(G::from_u64(0)), Op::Call(366, vec![6, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 7]), Op::Call(341, vec![8], 1, false), Op::Store(vec![6, 9, 7, 7])], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(295, vec![3], 1, false), Op::Load(12, 6), Op::Call(438, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(787, vec![4], 1, false), Op::AssertEq(vec![20], vec![19], Some("Const applied to wrong number of universe levels".into())), Op::Call(439, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(344, vec![21, 4], 1, false)], ctrl: Ctrl::Return(2, vec![22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(440, vec![3, 1], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![9, 4, 11], 1, false)], ctrl: Ctrl::Return(3, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(425, vec![6, 1], 1, false), Op::Load(4, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![14, 4, 16], 1, false)], ctrl: Ctrl::Return(4, vec![17]) })].into_iter().collect(), None) }))) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 1]), Op::Call(440, vec![4, 7], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![9, 3, 8, 6])], ctrl: Ctrl::Return(5, vec![10]) }), (G::from_u64(5), Block { ops: vec![Op::Call(442, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 3, 1]), Op::Call(442, vec![4, 8], 1, false), Op::Const(G::from_u64(1)), Op::Call(340, vec![6, 9], 1, false), Op::Store(vec![10, 11, 7, 7])], ctrl: Ctrl::Return(6, vec![12]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![5, 4, 6], 1, false), Op::Call(440, vec![7, 1], 1, false)], ctrl: Ctrl::Return(7, vec![8]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(389, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 9, 10])], ctrl: Ctrl::Return(8, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(226, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 9, 10])], ctrl: Ctrl::Return(9, vec![11]) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![Op::Call(440, vec![5, 1], 1, false), Op::Call(425, vec![6, 1], 1, false), Op::Call(122, vec![7], 2, false), Op::Load(4, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![11], vec![3], Some("projection's structure type differs from the value's head".into())), Op::Call(295, vec![11], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![27], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(298, vec![22, 23, 28], 1, false), Op::Load(12, 29)], ctrl: Ctrl::Match(30, [(G::from_u64(6), Block { ops: vec![Op::Call(344, vec![32, 12], 1, false), Op::Call(443, vec![42, 9, 18], 1, false), Op::Const(G::from_u64(0)), Op::Call(444, vec![43, 4, 44, 3, 5], 1, false)], ctrl: Ctrl::Return(10, vec![45]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 42, lookups: 13 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_442() -> Function { + Function { body: Block { ops: vec![Op::Call(440, vec![0, 1], 1, false), Op::Load(4, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(425, vec![2, 1], 1, false), Op::Load(4, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_443() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(375, vec![5, 8, 10], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 12), Op::Call(443, vec![11, 9, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_444() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![10, 3, 2, 4]), Op::Const(G::from_u64(0)), Op::Call(375, vec![7, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 14), Op::Call(444, vec![13, 1, 15, 3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![16]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_445() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(332, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(445, vec![4, 7], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_446() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(349, vec![1], 1, false), Op::Call(351, vec![4, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(448, vec![0, 1, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(447, vec![0, 1, 2, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_447() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(362, vec![0, 4], 1, false), Op::Call(362, vec![1, 4], 1, false), Op::Call(353, vec![5, 6], 1, false), Op::Call(787, vec![2], 1, false), Op::Call(353, vec![7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(361, vec![2, 3], 1, false), Op::Call(448, vec![0, 1, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(370, vec![0, 9, 10], 1, false), Op::Call(370, vec![1, 9, 10], 1, false), Op::Call(798, vec![2, 9], 1, false), Op::Sub(3, 9), Op::Call(361, vec![13, 14], 1, false), Op::Call(448, vec![11, 12, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_448() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(449, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(449, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![4]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 9, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_449() -> Function { + Function { body: Block { ops: vec![Op::Call(450, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(457, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![4]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_450() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(122, vec![1], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Load(4, 5)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Sub(8, 12)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Call(445, vec![9, 13], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![4], 1, false), Op::Call(787, vec![6], 1, false), Op::Sub(17, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Call(451, vec![4, 6, 2], 1, false)], ctrl: Ctrl::Return(1, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![20]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_451() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::Call(446, vec![4, 7, 2], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(451, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(4, vec![10]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_452() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(141, vec![3], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(155, vec![], 1, false), Op::Call(2, vec![2, 5], 1, false)], ctrl: Ctrl::Return(2, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_453() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]), Op::Call(253, vec![6], 1, false)], ctrl: Ctrl::Return(0, vec![5, 7, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(1, vec![5, 0, 7]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(156, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(453, vec![3], 3, false), Op::Const(G::from_u64(1)), Op::Call(123, vec![13], 1, false)], ctrl: Ctrl::Return(2, vec![14, 12, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(3, vec![11, 0, 13]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(170, vec![], 1, false), Op::Call(2, vec![10, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(15, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Call(453, vec![7], 3, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(125, vec![21, 17], 1, false)], ctrl: Ctrl::Return(4, vec![22, 20, 23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![22, 7, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(6, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(7, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16, 16, 16])], ctrl: Ctrl::Return(8, vec![15, 0, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14, 14, 14, 14, 14, 14, 14, 14])], ctrl: Ctrl::Return(9, vec![13, 0, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(10, vec![9, 0, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(11, vec![5, 0, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 12, auxiliaries: 23, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_454() -> Function { + Function { body: Block { ops: vec![Op::Call(452, vec![0], 1, false), Op::Call(452, vec![1], 1, false), Op::Mul(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(453, vec![0], 3, false), Op::Call(453, vec![1], 3, false), Op::Mul(6, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(346, vec![8, 11], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![14, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(446, vec![7, 10, 2], 1, false)], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_455() -> Function { + Function { body: Block { ops: vec![Op::Call(456, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(456, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![4]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_456() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(236, vec![5], 1, false), Op::Call(238, vec![7, 2], 1, false), Op::Call(446, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_457() -> Function { + Function { body: Block { ops: vec![Op::Call(456, vec![0, 1, 2], 1, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(456, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Yield(1, vec![4]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(458, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![5]) }))) })) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_458() -> Function { + Function { body: Block { ops: vec![Op::Call(427, vec![0, 2], 1, false), Op::Call(427, vec![1, 2], 1, false), Op::Sub(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(460, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(450, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(459, vec![0, 1, 3, 4, 2], 1, false)], ctrl: Ctrl::Return(3, vec![8]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_459() -> Function { + Function { body: Block { ops: vec![Op::Call(431, vec![2, 4], 1, false), Op::Call(431, vec![3, 4], 1, false), Op::Sub(5, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(460, vec![5, 6, 4], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(450, vec![5, 6, 4], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(461, vec![0, 1, 5, 6, 4], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_460() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(332, vec![4, 8], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![11]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(446, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(446, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(2, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![11]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(446, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(446, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(5, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_461() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(475, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(473, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(469, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(469, vec![3, 2, 4], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(454, vec![2, 3, 4], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(16)), Op::Call(480, vec![2, 3, 12, 4], 3, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(462, vec![0, 1, 14, 15, 4], 1, false)], ctrl: Ctrl::Return(7, vec![16]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 18, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_462() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(466, vec![2, 3, 5, 4], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(464, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(468, vec![0, 1, 4], 1, false)], ctrl: Ctrl::Return(2, vec![9]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_463() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(122, vec![1], 2, false), Op::Call(787, vec![4], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![4], 1, false), Op::Call(787, vec![6], 1, false), Op::Sub(8, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(11, [(G::from_u64(8), Block { ops: vec![Op::Load(4, 5)], ctrl: Ctrl::Match(15, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![12, 16], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Sub(13, 17)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(446, vec![14, 18, 2], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(451, vec![4, 6, 2], 1, false)], ctrl: Ctrl::Return(1, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 20, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_464() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(466, vec![0, 1, 3, 2], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(463, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(465, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_465() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(3), Block { ops: vec![Op::Call(464, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(464, vec![5, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_466() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Sub(6, 10)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![14, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![14, 2]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(3, vec![13, 14]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(332, vec![6, 10], 1, false)], ctrl: Ctrl::Return(4, vec![13, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(5, vec![13, 14]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![6, 10], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(445, vec![7, 11], 1, false)], ctrl: Ctrl::Return(6, vec![14, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(7, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(8, vec![13, 14]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(3), Block { ops: vec![Op::Call(466, vec![6, 10, 2, 3], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(466, vec![7, 11, 14, 3], 2, false)], ctrl: Ctrl::Return(9, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![15, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(11, vec![13, 14]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(4), Block { ops: vec![Op::Call(466, vec![6, 10, 2, 3], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 6, 3]), Op::Call(466, vec![7, 11, 14, 16], 2, false)], ctrl: Ctrl::Return(12, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![15, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(14, vec![13, 14]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Call(466, vec![6, 10, 2, 3], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 6, 3]), Op::Call(466, vec![7, 11, 14, 16], 2, false)], ctrl: Ctrl::Return(15, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(16, vec![15, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(17, vec![13, 14]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(7), Block { ops: vec![Op::Call(348, vec![6, 7, 10, 11], 1, false)], ctrl: Ctrl::Return(18, vec![13, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(19, vec![13, 14]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![6, 10], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Sub(7, 11)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Call(466, vec![8, 12, 2, 3], 2, false)], ctrl: Ctrl::Return(20, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(21, vec![15, 2]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(22, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(23, vec![13, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(24, vec![9, 10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 25, auxiliaries: 16, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_467() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 4), Op::Call(431, vec![0, 3], 1, false), Op::Call(431, vec![1, 3], 1, false), Op::Sub(6, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(454, vec![6, 7, 3], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![10, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(480, vec![6, 7, 11, 3], 3, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![15, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(466, vec![13, 14, 5, 3], 2, false)], ctrl: Ctrl::Return(4, vec![15, 16]) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_468() -> Function { + Function { body: Block { ops: vec![Op::Call(425, vec![0, 2], 1, false), Op::Call(425, vec![1, 2], 1, false), Op::Sub(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(475, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(473, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(469, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(469, vec![4, 3, 2], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(454, vec![3, 4, 2], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(472, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(478, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Return(7, vec![13]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 18, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_469() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![1], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(295, vec![6], 1, false), Op::Load(12, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(6), Block { ops: vec![Op::Call(787, vec![4], 1, false), Op::Add(16, 17), Op::Sub(22, 23)], ctrl: Ctrl::Match(24, [(G::from_u64(0), Block { ops: vec![Op::Call(297, vec![13, 14], 1, false), Op::Load(12, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(5), Block { ops: vec![Op::EqZero(30), Op::Const(G::from_u64(1)), Op::Sub(31, 39), Op::EqZero(40), Op::Mul(38, 41)], ctrl: Ctrl::Match(42, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![43]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(471, vec![13, 14], 1, false), Op::Call(418, vec![43], 1, false)], ctrl: Ctrl::Match(44, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![45]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(440, vec![0, 2], 1, false), Op::Call(440, vec![1, 2], 1, false), Op::Call(446, vec![45, 46, 2], 1, false)], ctrl: Ctrl::Match(47, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![48]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(470, vec![43, 16, 17, 0, 4, 48, 2], 1, false)], ctrl: Ctrl::Return(3, vec![49]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![38]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![25]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 48, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_470() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 5)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![8, 0, 5, 3]), Op::Add(1, 5), Op::Call(789, vec![4, 10], 1, false), Op::Call(446, vec![9, 11, 6], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 13), Op::Call(470, vec![0, 1, 2, 3, 4, 14, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) }))) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_471() -> Function { + Function { body: Block { ops: vec![Op::Call(301, vec![1], 8, false), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12]), Op::Call(78, vec![10, 2, 3, 4, 5, 6, 7, 8, 9, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 13, 13, 13, 13], 1, false), Op::Call(24, vec![14], 1, false)], ctrl: Ctrl::Return(0, vec![15]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_472() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(476, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(476, vec![8, 9, 0, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_473() -> Function { + Function { body: Block { ops: vec![Op::Call(440, vec![0, 2], 1, false), Op::Call(425, vec![3, 2], 1, false), Op::Call(474, vec![4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(440, vec![1, 2], 1, false), Op::Call(446, vec![3, 6, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_474() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(295, vec![4], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(13, 20)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(298, vec![15, 16, 22], 1, false), Op::Load(12, 23)], ctrl: Ctrl::Match(24, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![36]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![36]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 34, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_475() -> Function { + Function { body: Block { ops: vec![Op::Call(440, vec![0, 2], 1, false), Op::Call(477, vec![3, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(440, vec![1, 2], 1, false), Op::Call(446, vec![3, 5, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_476() -> Function { + Function { body: Block { ops: vec![Op::Call(440, vec![2, 3], 1, false), Op::Call(425, vec![4, 3], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(446, vec![0, 7, 3], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(366, vec![2, 11, 12], 1, false), Op::Store(vec![12, 12, 12, 12]), Op::Const(G::from_u64(3)), Op::Store(vec![15, 13, 14, 12]), Op::Store(vec![12, 0, 3]), Op::Call(446, vec![1, 16, 17], 1, false)], ctrl: Ctrl::Return(1, vec![18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![10]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 14, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_477() -> Function { + Function { body: Block { ops: vec![Op::Call(440, vec![0, 1], 1, false), Op::Call(425, vec![2, 1], 1, false), Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8]), Op::Call(332, vec![5, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_478() -> Function { + Function { body: Block { ops: vec![Op::Call(479, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_479() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Sub(4, 8)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![11]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(332, vec![4, 8], 1, false)], ctrl: Ctrl::Return(3, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![11]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(445, vec![5, 9], 1, false)], ctrl: Ctrl::Return(5, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(492, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(492, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(7, vec![11]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(3), Block { ops: vec![Op::Call(446, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(492, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(8, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(446, vec![5, 9, 2], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(492, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(9, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![13]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(492, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(11, vec![11]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(446, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(12, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(446, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(13, vec![14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(476, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(14, vec![11]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(446, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(15, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(446, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(16, vec![14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(17, vec![11]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(18, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(7), Block { ops: vec![Op::Call(348, vec![4, 5, 8, 9], 1, false)], ctrl: Ctrl::Return(19, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(407, vec![0], 1, false), Op::Sub(11, 0)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(20, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(479, vec![11, 1, 2], 1, false)], ctrl: Ctrl::Return(21, vec![13]) }))) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Sub(5, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(446, vec![6, 10, 2], 1, false)], ctrl: Ctrl::Return(22, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(23, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(24, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(25, vec![11]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 26, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_480() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5, 0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(454, vec![0, 1, 3], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![6, 0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(493, vec![0], 2, false), Op::Call(493, vec![1], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(482, vec![7, 9, 0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(3, vec![11, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(486, vec![7, 0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(4, vec![11, 12, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(487, vec![9, 0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(5, vec![11, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(488, vec![0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(6, vec![11, 12, 13]) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_481() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_482() -> Function { + Function { body: Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 6), Op::Call(295, vec![1], 1, false), Op::Load(12, 19), Op::Call(489, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(489, vec![20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], 1, false)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![34, 2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(484, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(1, vec![34, 35, 36]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Call(483, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(2, vec![34, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(481, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(481, vec![20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], 1, false), Op::U32LessThan(35, 34)], ctrl: Ctrl::Match(36, [(G::from_u64(1), Block { ops: vec![Op::Call(483, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(3, vec![37, 38, 39]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(34, 35)], ctrl: Ctrl::Match(37, [(G::from_u64(1), Block { ops: vec![Op::Call(484, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(4, vec![38, 39, 40]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(485, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(5, vec![38, 39, 40]) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 6, auxiliaries: 50, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_483() -> Function { + Function { body: Block { ops: vec![Op::Call(491, vec![0], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![5, 3], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Call(480, vec![6, 1, 8, 3], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6, 0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_484() -> Function { + Function { body: Block { ops: vec![Op::Call(491, vec![1], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![5, 3], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Call(480, vec![0, 6, 8, 3], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6, 0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_485() -> Function { + Function { body: Block { ops: vec![Op::Call(491, vec![0], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(491, vec![1], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(431, vec![5, 3], 1, false), Op::Call(431, vec![7, 3], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 10), Op::Call(480, vec![8, 9, 11, 3], 3, false)], ctrl: Ctrl::Return(0, vec![12, 13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8, 0, 1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![6, 0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_486() -> Function { + Function { body: Block { ops: vec![Op::Call(490, vec![2, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(480, vec![1, 6, 8, 4], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 7), Op::Call(489, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![21, 1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(494, vec![1, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 4], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 23), Op::Call(480, vec![22, 2, 24, 4], 3, false)], ctrl: Ctrl::Return(2, vec![25, 26, 27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![23, 1, 2]) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_487() -> Function { + Function { body: Block { ops: vec![Op::Call(490, vec![1, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(480, vec![6, 2, 8, 4], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 7), Op::Call(489, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![21, 1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(494, vec![2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 4], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 23), Op::Call(480, vec![1, 22, 24, 4], 3, false)], ctrl: Ctrl::Return(2, vec![25, 26, 27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![23, 1, 2]) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_488() -> Function { + Function { body: Block { ops: vec![Op::Call(490, vec![0, 3], 2, false), Op::Call(490, vec![1, 3], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(480, vec![5, 7, 9, 3], 3, false)], ctrl: Ctrl::Return(0, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(480, vec![5, 1, 9, 3], 3, false)], ctrl: Ctrl::Return(1, vec![10, 11, 12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(480, vec![0, 7, 9, 3], 3, false)], ctrl: Ctrl::Return(2, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8, 0, 1]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_489() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![12]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 3, auxiliaries: 3, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_490() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Load(4, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Call(431, vec![0, 1], 1, false), Op::Call(122, vec![8], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(8), Block { ops: vec![Op::Call(491, vec![7], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![17, 5, 6, 16]), Op::Const(G::from_u64(1)), Op::Call(263, vec![18, 3], 1, false)], ctrl: Ctrl::Return(0, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![17, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![15, 8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8, 0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 18, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_491() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(295, vec![4], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(344, vec![11, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(263, vec![20, 2], 1, false)], ctrl: Ctrl::Return(0, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(344, vec![11, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(263, vec![20, 2], 1, false)], ctrl: Ctrl::Return(1, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![20, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7, 0]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 22, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_492() -> Function { + Function { body: Block { ops: vec![Op::Call(493, vec![0], 2, false), Op::Call(493, vec![1], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![3], 1, false), Op::Load(12, 7), Op::Call(295, vec![5], 1, false), Op::Load(12, 20), Op::Call(494, vec![0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2], 2, false), Op::Call(494, vec![1, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2], 2, false)], ctrl: Ctrl::Match(33, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![Op::Call(446, vec![34, 36, 2], 1, false)], ctrl: Ctrl::Return(2, vec![37]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(446, vec![34, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![37]) }))) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![Op::Call(446, vec![0, 36, 2], 1, false)], ctrl: Ctrl::Return(4, vec![37]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![37]) }))) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 39, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_493() -> Function { + Function { body: Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(1, vec![8, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_494() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Call(491, vec![0], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(431, vec![15, 13], 1, false)], ctrl: Ctrl::Return(0, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![16, 0]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(491, vec![0], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(431, vec![15, 13], 1, false)], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![16, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![14, 0]) }))) }, layout: FunctionLayout { input_size: 14, selectors: 5, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_495() -> Function { + Function { body: Block { ops: vec![Op::Call(349, vec![0], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(497, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(496, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![3]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_496() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(362, vec![0, 3], 1, false), Op::Call(787, vec![1], 1, false), Op::Call(353, vec![4, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Call(361, vec![1, 2], 1, false), Op::Call(497, vec![0, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(370, vec![0, 6, 7], 1, false), Op::Call(798, vec![1, 6], 1, false), Op::Sub(2, 6), Op::Call(361, vec![9, 10], 1, false), Op::Call(497, vec![8, 11], 1, false), Op::Call(366, vec![12, 6, 7], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_497() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(789, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Const(G::from_u64(0)), Op::Call(366, vec![6, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 7]), Op::Call(341, vec![8], 1, false), Op::Store(vec![6, 9, 7, 7])], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(295, vec![3], 1, false), Op::Load(12, 6), Op::Call(438, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(787, vec![4], 1, false), Op::AssertEq(vec![20], vec![19], Some("Const applied to wrong number of universe levels".into())), Op::Call(439, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(344, vec![21, 4], 1, false)], ctrl: Ctrl::Return(2, vec![22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(495, vec![6, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(509, vec![8, 7, 10, 1], 1, false)], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Call(517, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 3, 1]), Op::Call(495, vec![4, 8], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![10, 3, 9, 7])], ctrl: Ctrl::Return(4, vec![11]) }), (G::from_u64(5), Block { ops: vec![Op::Call(517, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 3, 1]), Op::Call(517, vec![4, 8], 1, false), Op::Const(G::from_u64(1)), Op::Call(340, vec![6, 9], 1, false), Op::Store(vec![10, 11, 7, 7])], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(6), Block { ops: vec![Op::Call(498, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(7), Block { ops: vec![Op::Call(510, vec![3, 4], 1, false)], ctrl: Ctrl::Return(7, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(516, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(8, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 22, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_498() -> Function { + Function { body: Block { ops: vec![Op::Call(517, vec![0, 3], 1, false), Op::Call(518, vec![1, 0, 3], 0, false), Op::Call(787, vec![3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 5, 6, 6]), Op::Const(G::from_u64(2)), Op::Store(vec![8, 0, 1, 7, 5]), Op::Call(504, vec![2, 9, 3, 5], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_499() -> Function { + Function { body: Block { ops: vec![Op::Call(500, vec![0, 1], 2, false), Op::Sub(3, 5), Op::Const(G::from_u64(0)), Op::Call(366, vec![4, 6, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 4, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_500() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(437, vec![3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![7, 4]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(4, 7)], ctrl: Ctrl::Return(1, vec![3, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(500, vec![5, 8], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![3, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(500, vec![5, 8], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_501() -> Function { + Function { body: Block { ops: vec![Op::Call(502, vec![0, 1], 2, false), Op::Sub(2, 4), Op::Const(G::from_u64(0)), Op::Call(366, vec![3, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 4, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_502() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 1, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 4]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(1, vec![8, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(502, vec![5, 8], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(503, vec![4, 5, 6, 7], 1, false)], ctrl: Ctrl::Return(3, vec![8, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(502, vec![5, 8], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_503() -> Function { + Function { body: Block { ops: vec![Op::Call(349, vec![0], 1, false), Op::Call(0, vec![3, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Call(0, vec![7, 3], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(7, 3), Op::Call(502, vec![1, 11], 2, false), Op::Sub(2, 13), Op::Const(G::from_u64(0)), Op::Call(366, vec![12, 14, 15], 1, false), Op::Call(366, vec![16, 3, 15], 1, false)], ctrl: Ctrl::Return(2, vec![17]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(503, vec![7, 1, 2, 3], 1, false), Op::Call(503, vec![8, 1, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12, 13])], ctrl: Ctrl::Return(3, vec![14]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(503, vec![7, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Call(503, vec![8, 1, 2, 13], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 14, 15])], ctrl: Ctrl::Return(4, vec![16]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(503, vec![7, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Call(503, vec![8, 1, 2, 13], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 14, 15])], ctrl: Ctrl::Return(5, vec![16]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(503, vec![7, 1, 2, 3], 1, false), Op::Call(503, vec![8, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 13), Op::Call(503, vec![9, 1, 2, 14], 1, false), Op::Store(vec![10, 11, 12, 15])], ctrl: Ctrl::Return(6, vec![16]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(503, vec![9, 1, 2, 3], 1, false), Op::Store(vec![10, 7, 8, 11])], ctrl: Ctrl::Return(7, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![0]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_504() -> Function { + Function { body: Block { ops: vec![Op::Call(349, vec![0], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Call(495, vec![0, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(3), Block { ops: vec![Op::Call(505, vec![1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(508, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(354, vec![0, 10, 9], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(508, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(506, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![12]) })].into_iter().collect(), None) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(508, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_505() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(2), Block { ops: vec![Op::Call(505, vec![4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_506() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(362, vec![0, 4], 1, false), Op::Call(507, vec![1, 5], 3, false), Op::Call(370, vec![0, 7, 4], 1, false), Op::Call(798, vec![2, 8], 1, false), Op::Sub(3, 8), Op::Call(508, vec![9, 6, 10, 11], 1, false), Op::Call(366, vec![12, 8, 4], 1, false)], ctrl: Ctrl::Return(0, vec![13]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_507() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![0, 2, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(507, vec![5, 8], 3, false), Op::Add(10, 7)], ctrl: Ctrl::Return(1, vec![9, 12, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(507, vec![5, 8], 3, false), Op::Add(10, 7), Op::Add(11, 7)], ctrl: Ctrl::Return(2, vec![9, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![0, 7, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_508() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(500, vec![1, 5], 2, false), Op::Sub(3, 9), Op::Const(G::from_u64(0)), Op::Call(366, vec![8, 10, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(503, vec![5, 1, 3, 8], 1, false), Op::Call(517, vec![9, 2], 1, false), Op::Store(vec![8, 9, 2]), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Store(vec![12, 9, 13, 1, 8]), Op::Call(504, vec![6, 14, 11, 13], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![16, 9, 15, 8])], ctrl: Ctrl::Return(1, vec![17]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(503, vec![5, 1, 3, 8], 1, false), Op::Call(517, vec![9, 2], 1, false), Op::Store(vec![8, 9, 2]), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Store(vec![12, 9, 13, 1, 8]), Op::Call(504, vec![6, 14, 11, 13], 1, false), Op::Call(425, vec![15, 11], 1, false), Op::Load(4, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(340, vec![10, 18], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![21, 22, 23, 23])], ctrl: Ctrl::Return(2, vec![24]) })].into_iter().collect(), None) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(503, vec![5, 1, 3, 8], 1, false), Op::Call(517, vec![9, 2], 1, false), Op::Call(504, vec![6, 1, 2, 3], 1, false), Op::Call(446, vec![11, 9, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("delayed let value type mismatch".into())), Op::Const(G::from_u64(2)), Op::Store(vec![14, 9, 6, 1, 3]), Op::Call(504, vec![7, 15, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![16]) }), (G::from_u64(3), Block { ops: vec![Op::Call(504, vec![5, 1, 2, 3], 1, false), Op::Call(425, vec![8, 2], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(504, vec![6, 1, 2, 3], 1, false), Op::Call(446, vec![14, 11, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![15], vec![16], Some("delayed application type mismatch".into())), Op::Const(G::from_u64(0)), Op::Call(354, vec![12, 17, 16], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(370, vec![12, 19, 19], 1, false)], ctrl: Ctrl::Return(4, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(503, vec![6, 1, 3, 19], 1, false), Op::Call(375, vec![12, 20, 19], 1, false)], ctrl: Ctrl::Return(5, vec![21]) }))) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(503, vec![0, 1, 3, 8], 1, false), Op::Call(495, vec![9, 2], 1, false)], ctrl: Ctrl::Return(6, vec![10]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 17, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_509() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(379, vec![0, 2, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(787, vec![2], 1, false)], ctrl: Ctrl::MatchContinue(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(379, vec![8, 2, 12], 1, false)], ctrl: Ctrl::Yield(3, vec![13]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(518, vec![5, 12, 3], 0, false), Op::Const(G::from_u64(0)), Op::Store(vec![13, 5, 2]), Op::Call(509, vec![9, 6, 14, 3], 1, false)], ctrl: Ctrl::Return(4, vec![15]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![2], 1, false)], ctrl: Ctrl::MatchContinue(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(5, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(379, vec![0, 2, 12], 1, false)], ctrl: Ctrl::Yield(6, vec![13]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(425, vec![12, 3], 1, false), Op::Load(4, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![Op::Call(518, vec![5, 15, 3], 0, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Store(vec![18, 5, 20]), Op::Call(509, vec![16, 6, 21, 3], 1, false)], ctrl: Ctrl::Return(7, vec![22]) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 21, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_510() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(389, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 5, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(226, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 5, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_511() -> Function { + Function { body: Block { ops: vec![Op::Call(344, vec![0, 1], 1, false), Op::Call(512, vec![4, 2, 3], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10]), Op::Call(332, vec![7, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_512() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(425, vec![0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(425, vec![0, 2], 1, false), Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 2]), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(512, vec![6, 11, 9], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![3]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_513() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(517, vec![1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4]), Op::Call(332, vec![3, 5], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![6], vec![7], Some("projection on a Prop structure: field is not a Prop".into()))], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_514() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(517, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Call(332, vec![4, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![2], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![8], vec![9], Some("projection on a Prop structure: later fields depend on a data field".into()))], ctrl: Ctrl::Return(2, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_515() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(513, vec![5, 8, 6], 0, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(514, vec![5, 8, 9, 6], 0, false), Op::Const(G::from_u64(8)), Op::Store(vec![12, 3, 2, 4]), Op::Const(G::from_u64(0)), Op::Call(375, vec![9, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 16), Op::Call(515, vec![15, 1, 17, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![18]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_516() -> Function { + Function { body: Block { ops: vec![Op::Call(495, vec![2, 3], 1, false), Op::Call(425, vec![4, 3], 1, false), Op::Call(122, vec![5], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![9], vec![0], Some("projection's structure type differs from the value's head".into())), Op::Call(295, vec![9], 1, false), Op::Load(12, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![18], vec![25], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(298, vec![20, 21, 26], 1, false), Op::Load(12, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(6), Block { ops: vec![Op::Call(344, vec![30, 10], 1, false), Op::Call(443, vec![40, 7, 16], 1, false), Op::Add(16, 17), Op::Call(511, vec![15, 10, 42, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(515, vec![41, 1, 44, 0, 2, 43, 3], 1, false)], ctrl: Ctrl::Return(0, vec![45]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 39, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_517() -> Function { + Function { body: Block { ops: vec![Op::Call(495, vec![0, 1], 1, false), Op::Call(425, vec![2, 1], 1, false), Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_518() -> Function { + Function { body: Block { ops: vec![Op::Call(495, vec![0, 2], 1, false), Op::Call(446, vec![3, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], Some("inferred type is not def-eq to the expected type".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_519() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(240)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(225)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 4, 15, 16, 14, 17, 18, 19, 20, 21, 22, 23, 24, 25, 22, 12, 26, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_520() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(138)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(230)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 10, 25, 26, 9, 27, 28, 24])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_521() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(124)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(49)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_522() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(54)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(218)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 11, 16, 17, 18, 19, 20, 21, 16, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_523() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(140)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(75)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 18, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_524() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(173)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(238)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 9])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_525() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(227)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(9)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 3, 22, 23, 24, 25, 26, 27, 24, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_526() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(156)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(81)), Op::Store(vec![0, 1, 2, 3, 2, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 7, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_527() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(160)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(90)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 10, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 19, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_528() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(230)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(164)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 21, 0, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_529() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(212)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(251)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 3, 15, 3, 16, 17, 18, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_530() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(252)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(218)), Op::Store(vec![0, 1, 2, 3, 4, 5, 0, 6, 7, 8, 9, 10, 11, 8, 12, 13, 14, 15, 16, 17, 18, 19, 20, 8, 21, 10, 22, 23, 24, 25, 26, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_531() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(252)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(44)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 18])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_532() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(29)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(69)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_533() -> Function { + Function { body: Block { ops: vec![Op::Call(519, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(520, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(521, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(531, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(530, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(532, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![13]) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 19, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_534() -> Function { + Function { body: Block { ops: vec![Op::Call(531, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(530, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(532, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_535() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(158, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false), Op::Call(159, vec![], 1, false), Op::Call(2, vec![6, 11], 1, false), Op::Add(10, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![14, 14, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(14, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![18, 12, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19])], ctrl: Ctrl::Return(2, vec![18, 18, 20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19])], ctrl: Ctrl::Return(3, vec![18, 18, 20]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(4, vec![9, 9, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(5, vec![5, 5, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 20, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_536() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Call(158, vec![], 1, false)], ctrl: Ctrl::Yield(0, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(159, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![2]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Const(G::from_u64(0)), Op::Store(vec![3, 2, 5, 6]), Op::Const(G::from_u64(7)), Op::Store(vec![8, 6, 1, 6]), Op::Const(G::from_u64(3)), Op::Store(vec![10, 7, 9, 6])], ctrl: Ctrl::Return(2, vec![11]) })) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_537() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![2], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![2, 7], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![2, 9], 1, false), Op::Call(535, vec![8], 3, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(535, vec![10], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(1, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(538, vec![0, 1, 2, 8, 10, 3], 2, false)], ctrl: Ctrl::Return(2, vec![17, 18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(538, vec![0, 1, 2, 8, 10, 3], 2, false)], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 20, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_538() -> Function { + Function { body: Block { ops: vec![Op::Call(425, vec![3, 5], 1, false), Op::Call(425, vec![4, 5], 1, false), Op::Call(535, vec![6], 3, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(535, vec![7], 3, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(536, vec![9, 10], 1, false), Op::Call(536, vec![12, 13], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![16, 0, 1, 17]), Op::Const(G::from_u64(3)), Op::Store(vec![19, 18, 14, 17]), Op::Store(vec![19, 20, 15, 17]), Op::Call(798, vec![2, 16], 1, false), Op::Const(G::from_u64(1)), Op::Call(263, vec![21, 22], 1, false)], ctrl: Ctrl::Return(0, vec![23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(1, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 16, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_539() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![2], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(534, vec![0], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(537, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(519, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false), Op::Call(520, vec![], 1, false), Op::Call(2, vec![0, 10], 1, false), Op::Call(521, vec![], 1, false), Op::Call(2, vec![0, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(540, vec![1, 2, 3], 2, false)], ctrl: Ctrl::Return(2, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(541, vec![9, 11, 0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_540() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![1, 5], 1, false), Op::Call(425, vec![4, 2], 1, false), Op::Call(251, vec![7], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(123, vec![9], 1, false), Op::Call(253, vec![10], 1, false), Op::Const(G::from_u64(2)), Op::Call(519, vec![], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 13, 0, 14]), Op::Const(G::from_u64(3)), Op::Store(vec![16, 15, 11, 14]), Op::Store(vec![16, 17, 6, 14]), Op::Call(798, vec![1, 12], 1, false), Op::Const(G::from_u64(1)), Op::Call(263, vec![18, 19], 1, false)], ctrl: Ctrl::Return(1, vec![20, 21]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 14, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_541() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![4, 6], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![4, 8], 1, false), Op::Call(425, vec![7, 5], 1, false), Op::Call(425, vec![9, 5], 1, false), Op::Call(251, vec![10], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(0, vec![14, 15]) }), (G::from_u64(1), Block { ops: vec![Op::Call(251, vec![11], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(1, vec![16, 17]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(1), Block { ops: vec![Op::Call(132, vec![13, 15], 1, false)], ctrl: Ctrl::Yield(2, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(346, vec![13, 15], 1, false)], ctrl: Ctrl::Yield(3, vec![16]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(542, vec![0, 1, 16, 7, 9, 2, 3, 4, 5], 2, false)], ctrl: Ctrl::Return(4, vec![17, 18]) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 5, auxiliaries: 14, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_542() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(9, 2), Op::Mul(0, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(0, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13]), Op::Store(vec![12, 14, 13]), Op::Store(vec![12, 12, 12]), Op::Store(vec![13, 15, 16]), Op::Const(G::from_u64(2)), Op::Call(529, vec![], 1, false), Op::Store(vec![18, 19, 17, 13]), Op::Call(528, vec![], 1, false), Op::Store(vec![18, 21, 16, 13])], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(1), Block { ops: vec![Op::Call(184, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(185, vec![], 1, false)], ctrl: Ctrl::Yield(2, vec![23]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![25, 25, 25]), Op::Const(G::from_u64(0)), Op::Store(vec![24, 23, 26, 27]), Op::Const(G::from_u64(3)), Op::Store(vec![29, 20, 22, 27]), Op::Store(vec![29, 30, 28, 27])], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(524, vec![], 1, false)], ctrl: Ctrl::Yield(3, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(525, vec![], 1, false)], ctrl: Ctrl::Yield(4, vec![32]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(526, vec![], 1, false)], ctrl: Ctrl::Yield(5, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(527, vec![], 1, false)], ctrl: Ctrl::Yield(6, vec![32]) }))) })), 1, 3, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![34, 34, 34]), Op::Const(G::from_u64(0)), Op::Store(vec![33, 32, 35, 36]), Op::Const(G::from_u64(3)), Op::Store(vec![38, 37, 3, 36]), Op::Store(vec![38, 39, 4, 36]), Op::Store(vec![38, 40, 31, 36]), Op::Call(545, vec![2, 41, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(7, vec![42, 43]) })) })) }))) }, layout: FunctionLayout { input_size: 9, selectors: 8, auxiliaries: 29, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_543() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![1], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![1, 6], 1, false), Op::Const(G::from_u64(1)), Op::Call(789, vec![1, 8], 1, false), Op::Load(4, 7)], ctrl: Ctrl::Match(10, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(347, vec![12, 16], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(1, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(544, vec![12, 0, 1, 2], 2, false)], ctrl: Ctrl::Return(2, vec![19, 20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18, 18])], ctrl: Ctrl::Return(3, vec![18, 19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18, 18])], ctrl: Ctrl::Return(4, vec![18, 19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(5, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(6, vec![14, 15]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 23, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_544() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 6, 5]), Op::Store(vec![4, 4, 4]), Op::Store(vec![5, 7, 8]), Op::Const(G::from_u64(2)), Op::Call(529, vec![], 1, false), Op::Store(vec![10, 11, 9, 5]), Op::Call(226, vec![], 1, false), Op::Store(vec![10, 13, 8, 5]), Op::Const(G::from_u64(7)), Op::Store(vec![15, 4, 0, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![17, 12, 14, 5]), Op::Store(vec![17, 18, 16, 5]), Op::Store(vec![10, 1, 8, 5]), Op::Call(797, vec![2, 10], 1, false), Op::Call(263, vec![20, 21], 1, false), Op::Call(495, vec![22, 3], 1, false), Op::Call(425, vec![23, 3], 1, false), Op::Call(122, vec![24], 2, false), Op::Call(787, vec![26], 1, false), Op::U32LessThan(27, 4)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![29, 29, 29, 29])], ctrl: Ctrl::Return(0, vec![29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![26, 29], 1, false), Op::Const(G::from_u64(2)), Op::Call(522, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![33, 33, 33]), Op::Store(vec![31, 32, 34, 29]), Op::Const(G::from_u64(3)), Op::Store(vec![36, 35, 30, 29]), Op::Store(vec![36, 37, 19, 29]), Op::Call(798, vec![2, 31], 1, false), Op::Call(263, vec![38, 39], 1, false)], ctrl: Ctrl::Return(1, vec![33, 40]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 35, lookups: 33 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_545() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(1), Block { ops: vec![Op::Call(522, vec![], 1, false)], ctrl: Ctrl::Yield(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(523, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![6]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 2, 3, 8]), Op::Call(797, vec![4, 7], 1, false), Op::Call(263, vec![9, 10], 1, false), Op::Call(495, vec![11, 5], 1, false), Op::Call(425, vec![12, 5], 1, false), Op::Call(122, vec![13], 2, false), Op::Call(787, vec![15], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(16, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(2, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![15, 19], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22]), Op::Store(vec![21, 6, 23, 19]), Op::Const(G::from_u64(3)), Op::Store(vec![25, 24, 20, 19]), Op::Store(vec![25, 26, 1, 19]), Op::Call(798, vec![4, 21], 1, false), Op::Call(263, vec![27, 28], 1, false)], ctrl: Ctrl::Return(3, vec![22, 29]) }))) })) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 26, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_546() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![4]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_547() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_548() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 1]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_549() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_550() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 1]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_551() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Mul(1, 3)], ctrl: Ctrl::Return(0, vec![2, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_552() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_553() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Call(554, vec![2, 3, 4, 5, 34, 35, 36, 37], 1, false), Op::Call(554, vec![6, 7, 8, 9, 38, 39, 40, 41], 1, false), Op::Call(554, vec![10, 11, 12, 13, 42, 43, 44, 45], 1, false), Op::Call(554, vec![14, 15, 16, 17, 46, 47, 48, 49], 1, false), Op::Call(554, vec![18, 19, 20, 21, 50, 51, 52, 53], 1, false), Op::Call(554, vec![22, 23, 24, 25, 54, 55, 56, 57], 1, false), Op::Call(554, vec![26, 27, 28, 29, 58, 59, 60, 61], 1, false), Op::Call(554, vec![30, 31, 32, 33, 62, 63, 64, 65], 1, false), Op::Call(547, vec![72, 73], 1, false), Op::Call(547, vec![71, 74], 1, false), Op::Call(547, vec![70, 75], 1, false), Op::Call(547, vec![69, 76], 1, false), Op::Call(547, vec![68, 77], 1, false), Op::Call(547, vec![67, 78], 1, false), Op::Call(547, vec![66, 79], 1, false)], ctrl: Ctrl::Return(0, vec![80]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 80, lookups: 18 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_554() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(16777216)), Op::Mul(0, 8), Op::Const(G::from_u64(65536)), Op::Mul(1, 10), Op::Const(G::from_u64(256)), Op::Mul(2, 12), Op::Add(13, 3), Op::Add(11, 14), Op::Add(9, 15), Op::Mul(4, 8), Op::Mul(5, 10), Op::Mul(6, 12), Op::Add(19, 7), Op::Add(18, 20), Op::Add(17, 21), Op::Call(546, vec![16, 22], 1, false)], ctrl: Ctrl::Return(0, vec![23]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_555() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 4)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(555, vec![0, 5], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_556() -> Function { + Function { body: Block { ops: vec![Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(555, vec![0, 2], 1, false), Op::Call(555, vec![1, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(553, vec![0, 1], 1, false), Op::Call(552, vec![6], 2, false)], ctrl: Ctrl::Return(1, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(2, vec![6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(3, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(546, vec![4, 5], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![6, 7]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_557() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Call(557, vec![3, 6], 1, false)], ctrl: Ctrl::Return(3, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(6, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(557, vec![3, 6], 1, false), Op::Call(557, vec![4, 7], 1, false), Op::Call(547, vec![8, 9], 1, false)], ctrl: Ctrl::Return(7, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(9, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(10, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(11, vec![8]) }), (G::from_u64(3), Block { ops: vec![Op::Call(557, vec![3, 6], 1, false), Op::Call(557, vec![4, 7], 1, false), Op::Call(547, vec![8, 9], 1, false)], ctrl: Ctrl::Return(12, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(4), Block { ops: vec![Op::Call(546, vec![3, 6], 1, false)], ctrl: Ctrl::Return(14, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(15, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 16, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_558() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(557, vec![3, 6], 1, false), Op::Call(558, vec![4, 7], 1, false), Op::Call(547, vec![8, 9], 1, false)], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_559() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(560, vec![1, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![4]) }), (G::from_u64(1), Block { ops: vec![Op::Call(563, vec![1, 3], 1, false)], ctrl: Ctrl::Return(3, vec![4]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_560() -> Function { + Function { body: Block { ops: vec![Op::Call(130, vec![0], 1, false), Op::Call(130, vec![1], 1, false), Op::Call(790, vec![2], 1, false), Op::Call(790, vec![3], 1, false), Op::Call(546, vec![4, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(561, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_561() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(561, vec![11, 21], 1, false), Op::Call(562, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(547, vec![22, 23], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 24, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_562() -> Function { + Function { body: Block { ops: vec![Op::Call(546, vec![7, 15], 1, false), Op::Call(546, vec![6, 14], 1, false), Op::Call(546, vec![5, 13], 1, false), Op::Call(546, vec![4, 12], 1, false), Op::Call(546, vec![3, 11], 1, false), Op::Call(546, vec![2, 10], 1, false), Op::Call(546, vec![1, 9], 1, false), Op::Call(546, vec![0, 8], 1, false), Op::Call(547, vec![22, 23], 1, false), Op::Call(547, vec![21, 24], 1, false), Op::Call(547, vec![20, 25], 1, false), Op::Call(547, vec![19, 26], 1, false), Op::Call(547, vec![18, 27], 1, false), Op::Call(547, vec![17, 28], 1, false), Op::Call(547, vec![16, 29], 1, false)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_563() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(546, vec![3, 6], 1, false), Op::Call(563, vec![4, 7], 1, false), Op::Call(547, vec![8, 9], 1, false)], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_564() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0), Op::Load(4, 1), Op::Call(565, vec![4, 5, 6, 7, 8, 9, 10, 11, 2], 2, false)], ctrl: Ctrl::Return(1, vec![12, 13]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_565() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(546, vec![1, 5], 1, false), Op::Call(552, vec![9], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(1, vec![9, 10]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(557, vec![1, 5], 1, false), Op::Call(552, vec![9], 2, false)], ctrl: Ctrl::Return(3, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(5, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(6, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(558, vec![2, 6], 1, false), Op::Call(552, vec![9], 2, false), Op::Call(556, vec![1, 5, 8], 2, false), Op::Call(551, vec![10, 11, 12, 13], 2, false)], ctrl: Ctrl::Return(7, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(8, vec![9, 10]) }))) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(9, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(10, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(11, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(564, vec![1, 5, 8], 2, false), Op::Call(564, vec![2, 6, 8], 2, false), Op::Call(551, vec![9, 10, 11, 12], 2, false)], ctrl: Ctrl::Return(12, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(13, vec![9, 10]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(14, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(15, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(16, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(17, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(564, vec![1, 5, 8], 2, false), Op::Call(564, vec![2, 6, 8], 2, false), Op::Call(551, vec![9, 10, 11, 12], 2, false)], ctrl: Ctrl::Return(18, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(19, vec![9, 10]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(20, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(21, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(22, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(23, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(24, vec![9, 10]) }), (G::from_u64(5), Block { ops: vec![Op::Call(564, vec![1, 5, 8], 2, false), Op::Call(564, vec![2, 6, 8], 2, false), Op::Call(551, vec![9, 10, 11, 12], 2, false)], ctrl: Ctrl::Return(25, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(26, vec![9, 10]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(27, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(28, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(29, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(30, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(31, vec![9, 10]) }), (G::from_u64(5), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(32, vec![9, 10]) }), (G::from_u64(6), Block { ops: vec![Op::Call(564, vec![1, 5, 8], 2, false), Op::Call(564, vec![2, 6, 8], 2, false), Op::Call(564, vec![3, 7, 8], 2, false), Op::Call(551, vec![11, 12, 13, 14], 2, false), Op::Call(551, vec![9, 10, 15, 16], 2, false)], ctrl: Ctrl::Return(33, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(34, vec![9, 10]) }))) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(35, vec![9, 10]) }), (G::from_u64(7), Block { ops: vec![Op::Call(559, vec![1, 2, 5, 6], 1, false), Op::Call(552, vec![9], 2, false)], ctrl: Ctrl::Return(36, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(37, vec![9, 10]) }))) }), (G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Call(556, vec![1, 5, 8], 2, false), Op::Call(546, vec![2, 6], 1, false), Op::Call(552, vec![11], 2, false), Op::Call(564, vec![3, 7, 8], 2, false), Op::Call(551, vec![12, 13, 14, 15], 2, false), Op::Call(551, vec![9, 10, 16, 17], 2, false)], ctrl: Ctrl::Return(38, vec![18, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(39, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 40, auxiliaries: 12, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_566() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(546, vec![1, 4], 1, false), Op::Call(552, vec![7], 2, false), Op::Call(564, vec![2, 5, 6], 2, false), Op::Call(551, vec![8, 9, 10, 11], 2, false)], ctrl: Ctrl::Return(0, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 7, selectors: 1, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_567() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(5, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(548, vec![], 2, false)], ctrl: Ctrl::Return(1, vec![13, 14]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(5, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(550, vec![], 2, false)], ctrl: Ctrl::Return(2, vec![13, 14]) }), (G::from_u64(0), Block { ops: vec![Op::Call(566, vec![4, 5, 6, 9, 10, 11, 2], 2, false), Op::Call(567, vec![7, 12, 2], 2, false), Op::Call(551, vec![13, 14, 15, 16], 2, false)], ctrl: Ctrl::Return(3, vec![17, 18]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 17, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_568() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![12]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![12]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(6, vec![12]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(7, vec![12]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 8, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_569() -> Function { + Function { body: Block { ops: vec![Op::Call(568, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false), Op::Call(568, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false), Op::Call(546, vec![25, 26], 1, false)], ctrl: Ctrl::Match(27, [(G::from_u64(1), Block { ops: vec![Op::Call(570, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 2, false)], ctrl: Ctrl::Return(0, vec![28, 29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(552, vec![27], 2, false)], ctrl: Ctrl::Return(1, vec![28, 29]) }))) }, layout: FunctionLayout { input_size: 25, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_570() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(546, vec![1, 13], 1, false), Op::Call(552, vec![25], 2, false), Op::Call(564, vec![2, 14, 24], 2, false), Op::Call(564, vec![3, 15, 24], 2, false), Op::Call(551, vec![28, 29, 30, 31], 2, false), Op::Call(551, vec![26, 27, 32, 33], 2, false)], ctrl: Ctrl::Return(0, vec![34, 35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(1, vec![25, 26]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(5), Block { ops: vec![Op::Call(546, vec![6, 18], 1, false), Op::Call(552, vec![25], 2, false), Op::Call(546, vec![1, 13], 1, false), Op::Call(552, vec![28], 2, false), Op::Call(546, vec![3, 15], 1, false), Op::Call(552, vec![31], 2, false), Op::Call(546, vec![4, 16], 1, false), Op::Call(552, vec![34], 2, false), Op::Call(551, vec![32, 33, 35, 36], 2, false), Op::Call(551, vec![29, 30, 37, 38], 2, false), Op::Call(551, vec![26, 27, 39, 40], 2, false), Op::Call(546, vec![5, 17], 1, false)], ctrl: Ctrl::Match(43, [(G::from_u64(1), Block { ops: vec![Op::Call(564, vec![2, 14, 24], 2, false), Op::Const(G::from_u64(0)), Op::Call(571, vec![7, 8, 19, 20, 5, 24, 46], 2, false), Op::Call(551, vec![44, 45, 47, 48], 2, false), Op::Call(551, vec![41, 42, 49, 50], 2, false)], ctrl: Ctrl::Return(2, vec![51, 52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(552, vec![43], 2, false), Op::Call(551, vec![41, 42, 44, 45], 2, false)], ctrl: Ctrl::Return(3, vec![46, 47]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(4, vec![25, 26]) }))) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(7), Block { ops: vec![Op::Call(546, vec![1, 13], 1, false), Op::Call(552, vec![25], 2, false), Op::Call(546, vec![3, 15], 1, false), Op::Call(552, vec![28], 2, false), Op::Call(546, vec![4, 16], 1, false), Op::Call(552, vec![31], 2, false), Op::Call(546, vec![5, 17], 1, false), Op::Call(552, vec![34], 2, false), Op::Call(546, vec![6, 18], 1, false), Op::Call(552, vec![37], 2, false), Op::Call(546, vec![8, 20], 1, false), Op::Call(552, vec![40], 2, false), Op::Call(564, vec![2, 14, 24], 2, false), Op::Call(567, vec![7, 19, 24], 2, false), Op::Call(551, vec![43, 44, 45, 46], 2, false), Op::Call(551, vec![41, 42, 47, 48], 2, false), Op::Call(551, vec![38, 39, 49, 50], 2, false), Op::Call(551, vec![35, 36, 51, 52], 2, false), Op::Call(551, vec![32, 33, 53, 54], 2, false), Op::Call(551, vec![29, 30, 55, 56], 2, false), Op::Call(551, vec![26, 27, 57, 58], 2, false)], ctrl: Ctrl::Return(5, vec![59, 60]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(6, vec![25, 26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(7, vec![25, 26]) }))) }, layout: FunctionLayout { input_size: 25, selectors: 8, auxiliaries: 37, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_571() -> Function { + Function { body: Block { ops: vec![Op::Sub(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(549, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0, 1, 6], 1, false), Op::Load(12, 8), Op::Call(298, vec![2, 3, 6], 1, false), Op::Load(12, 21), Op::Call(572, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 5], 2, false), Op::Const(G::from_u64(1)), Op::Add(6, 36), Op::Call(571, vec![0, 1, 2, 3, 4, 5, 37], 2, false), Op::Call(551, vec![34, 35, 38, 39], 2, false)], ctrl: Ctrl::Return(1, vec![40, 41]) }))) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 34, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_572() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(6), Block { ops: vec![Op::Call(546, vec![1, 13], 1, false), Op::Call(552, vec![25], 2, false), Op::Call(546, vec![5, 17], 1, false), Op::Call(552, vec![28], 2, false), Op::Call(546, vec![6, 18], 1, false), Op::Call(552, vec![31], 2, false), Op::Call(546, vec![7, 19], 1, false), Op::Call(552, vec![34], 2, false), Op::Call(564, vec![2, 14, 24], 2, false), Op::Call(551, vec![35, 36, 37, 38], 2, false), Op::Call(551, vec![32, 33, 39, 40], 2, false), Op::Call(551, vec![29, 30, 41, 42], 2, false), Op::Call(551, vec![26, 27, 43, 44], 2, false)], ctrl: Ctrl::Return(0, vec![45, 46]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(568, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false), Op::Call(568, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false), Op::Call(546, vec![25, 26], 1, false), Op::Call(552, vec![27], 2, false)], ctrl: Ctrl::Return(1, vec![28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(568, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false), Op::Call(568, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false), Op::Call(546, vec![25, 26], 1, false), Op::Call(552, vec![27], 2, false)], ctrl: Ctrl::Return(2, vec![28, 29]) }))) }, layout: FunctionLayout { input_size: 25, selectors: 3, auxiliaries: 23, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_573() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(301, vec![1], 8, false), Op::Call(301, vec![2], 8, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(78, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 22, 22, 22, 22], 1, false), Op::Call(24, vec![23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_574() -> Function { + Function { body: Block { ops: vec![Op::Call(789, vec![0, 1], 1, false), Op::Call(295, vec![2], 1, false), Op::Load(12, 3)], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_575() -> Function { + Function { body: Block { ops: vec![Op::Call(574, vec![0, 1], 12, false)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_576() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(787, vec![0], 1, false), Op::Call(577, vec![0, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_577() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::Call(578, vec![6, 1, 2, 3, 4], 2, false), Op::Const(G::from_u64(1)), Op::Add(3, 10), Op::Add(4, 9), Op::Call(577, vec![7, 1, 2, 11, 12], 1, false), Op::Call(782, vec![8, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_578() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(578, vec![7, 1, 2, 3, 4], 2, false), Op::Call(575, vec![1, 6], 1, false), Op::Const(G::from_u64(0)), Op::Call(579, vec![2, 6, 10, 4, 11], 1, false), Op::Call(789, vec![1, 6], 1, false), Op::Call(782, vec![12, 8], 1, false), Op::Store(vec![11, 13, 3, 14]), Op::U32LessThan(9, 10)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![15, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![15, 9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 18, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_579() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(573, vec![0, 1, 4], 1, false), Op::Add(3, 4), Op::Const(G::from_u64(1)), Op::Add(4, 9), Op::Call(579, vec![0, 1, 2, 3, 10], 1, false), Op::Store(vec![6, 7, 8, 11])], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_580() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![3, 0, 5]), Op::Call(787, vec![0], 1, false), Op::Add(4, 7), Op::Call(581, vec![6, 1, 2, 8], 1, false)], ctrl: Ctrl::Return(0, vec![9]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_581() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(787, vec![0], 1, false), Op::Call(577, vec![0, 1, 2, 4, 5], 1, false), Op::Call(582, vec![0, 6, 1], 1, false), Op::Call(588, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 9), Op::Call(581, vec![7, 1, 2, 10], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_582() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(583, vec![4, 1, 2], 1, false), Op::Call(582, vec![5, 1, 2], 1, false), Op::Call(786, vec![6, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_583() -> Function { + Function { body: Block { ops: vec![Op::Call(787, vec![0], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 0, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(584, vec![0, 1, 2], 1, false), Op::Call(586, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![5]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_584() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(584, vec![5, 1, 2], 1, false), Op::Call(585, vec![4, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_585() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![7, 0, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(574, vec![3, 0], 12, false), Op::Call(574, vec![3, 5], 12, false), Op::Call(569, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 2], 2, false)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![33, 0, 1])], ctrl: Ctrl::Return(1, vec![34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(585, vec![0, 6, 2, 3], 1, false), Op::Store(vec![33, 5, 34])], ctrl: Ctrl::Return(2, vec![35]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 33, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_586() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 4, 8]), Op::Call(587, vec![5, 1, 2, 4, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_587() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![8, 4, 10])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(574, vec![2, 3], 12, false), Op::Call(574, vec![2, 6], 12, false), Op::Call(569, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1], 2, false)], ctrl: Ctrl::Match(32, [(G::from_u64(1), Block { ops: vec![Op::Call(780, vec![4, 6], 1, false), Op::Call(587, vec![7, 1, 2, 6, 34], 1, false)], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35]), Op::Store(vec![34, 6, 36]), Op::Call(587, vec![7, 1, 2, 6, 37], 1, false), Op::Store(vec![34, 4, 38])], ctrl: Ctrl::Return(2, vec![39]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 35, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_588() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(347, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(588, vec![4, 7], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_589() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(589, vec![3], 1, false), Op::Call(786, vec![2, 4], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_590() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(787, vec![2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(590, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_591() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49])], ctrl: Ctrl::Return(0, vec![50]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 49), Op::Call(591, vec![48, 50], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![52, 1, 51])], ctrl: Ctrl::Return(1, vec![53]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![51]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 50, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_592() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![49]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(49, 1)], ctrl: Ctrl::Yield(2, vec![50]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(3, vec![49]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(49, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![50]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(592, vec![48, 1], 1, false)], ctrl: Ctrl::Return(5, vec![50]) }))) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 51, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_593() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(592, vec![2, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(592, vec![2, 51], 1, false), Op::Mul(50, 52), Op::AssertEq(vec![53], vec![51], Some("mutual block mixes a definition member with inductives".into())), Op::Call(591, vec![2, 51], 1, false), Op::Call(787, vec![54], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(55, 56)], ctrl: Ctrl::Match(57, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(303, vec![2, 0], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![60, 60, 60]), Op::Store(vec![59, 54, 61]), Op::Call(787, vec![54], 1, false), Op::Add(60, 63), Op::Call(581, vec![62, 58, 0, 64], 1, false), Op::Call(590, vec![65], 1, false), Op::AssertEq(vec![66], vec![60], Some("canonical block: refinement left members tied, order ambiguous".into())), Op::Call(589, vec![65], 1, false), Op::Call(347, vec![67, 54], 1, false), Op::AssertEq(vec![68], vec![60], Some("canonical block: members are not in canonical order".into()))], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 69, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_594() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![12]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![12]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![4]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![8]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_595() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) }), (G::from_u64(2), Block { ops: vec![Op::Call(295, vec![2], 1, false), Op::Load(12, 5), Op::Const(G::from_u64(1)), Op::Call(594, vec![6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Sub(18, 19)], ctrl: Ctrl::Return(2, vec![20]) }), (G::from_u64(3), Block { ops: vec![Op::Call(595, vec![2], 1, false), Op::Call(595, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(595, vec![2], 1, false), Op::Call(595, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(5), Block { ops: vec![Op::Call(595, vec![2], 1, false), Op::Call(595, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(5, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Call(595, vec![2], 1, false), Op::Call(595, vec![3], 1, false), Op::Call(595, vec![4], 1, false), Op::Mul(6, 7), Op::Mul(5, 8)], ctrl: Ctrl::Return(6, vec![9]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![5]) }), (G::from_u64(8), Block { ops: vec![Op::Call(595, vec![4], 1, false)], ctrl: Ctrl::Return(8, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 19, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_596() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(595, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![2], vec![3], Some("safe constant references an unsafe constant".into()))], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_597() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(597, vec![3, 1], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Call(597, vec![3, 1], 0, false), Op::Call(597, vec![4, 1], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Call(597, vec![3, 1], 0, false), Op::Call(597, vec![4, 1], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::U32LessThan(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("universe param index out of range".into()))], ctrl: Ctrl::Return(4, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_598() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(597, vec![3, 1], 0, false), Op::Call(598, vec![4, 1], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_599() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("loose bound variable: BVar index exceeds binder depth".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(597, vec![4, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Call(295, vec![4], 1, false), Op::Load(12, 7), Op::Call(438, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(787, vec![5], 1, false), Op::AssertEq(vec![21], vec![20], Some("Const applied to wrong number of universe levels".into())), Op::Call(598, vec![5, 2], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Call(599, vec![4, 1, 2], 0, false), Op::Call(599, vec![5, 1, 2], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Call(599, vec![4, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(599, vec![5, 8, 2], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Call(599, vec![4, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(599, vec![5, 8, 2], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Call(599, vec![4, 1, 2], 0, false), Op::Call(599, vec![5, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(599, vec![6, 8, 2], 0, false)], ctrl: Ctrl::Return(6, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![]) }), (G::from_u64(8), Block { ops: vec![Op::Call(599, vec![6, 1, 2], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 20, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_600() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(69)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(250)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 20, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_601() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(195)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(7)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 6, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_602() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 8), Op::Call(602, vec![6, 1, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_603() -> Function { + Function { body: Block { ops: vec![Op::Call(601, vec![], 1, false), Op::Call(295, vec![0], 1, false), Op::Load(12, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![14], Some("Eq inductive: wrong universe param count".into())), Op::Const(G::from_u64(2)), Op::AssertEq(vec![5], vec![15], Some("Eq inductive: wrong parameter count".into())), Op::AssertEq(vec![7], vec![14], Some("Eq inductive: wrong constructor count".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_604() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Call(600, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.Typ declared at a non-canonical address".into())), Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(0, vec![6, 7]) }), (G::from_u64(1), Block { ops: vec![Op::Call(390, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.mk declared at a non-canonical address".into())), Op::Const(G::from_u64(3))], ctrl: Ctrl::Yield(1, vec![6, 7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(391, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.lift declared at a non-canonical address".into())), Op::Call(603, vec![], 0, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(6))], ctrl: Ctrl::Yield(2, vec![7, 8]) }), (G::from_u64(3), Block { ops: vec![Op::Call(392, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.ind declared at a non-canonical address".into())), Op::Const(G::from_u64(5))], ctrl: Ctrl::Yield(3, vec![6, 7]) })].into_iter().collect(), None, 2, 2, 3, Box::new(Block { ops: vec![Op::AssertEq(vec![2], vec![4], Some("Quot constant: wrong universe param count for its kind".into())), Op::Const(G::from_u64(0)), Op::Call(602, vec![3, 5, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("Quot constant: type has too few foralls for its kind".into()))], ctrl: Ctrl::Return(4, vec![]) })) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_605() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(605, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_606() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(787, vec![0], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![3], vec![4], Some("more universe levels than the inductive declares".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(6, [(G::from_u64(4), Block { ops: vec![Op::AssertEq(vec![7], vec![2], Some("ctor return type: universe level is not Param(i) in order".into())), Op::Const(G::from_u64(1)), Op::Sub(1, 9), Op::Add(2, 9), Op::Call(606, vec![5, 10, 11], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_607() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Add(2, 1), Op::Const(G::from_u64(1)), Op::Sub(12, 13), Op::Sub(14, 3), Op::AssertEq(vec![9], vec![15], Some("ctor return type: param arg is not the expected param BVar".into())), Op::Add(3, 13), Op::Call(607, vec![7, 1, 2, 16], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_608() -> Function { + Function { body: Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![11, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], Some("ctor return head belongs to a different block".into())), Op::AssertEq(vec![12], vec![2], Some("ctor return head is a different member of the block".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_609() -> Function { + Function { body: Block { ops: vec![Op::Add(1, 3), Op::Call(605, vec![0, 7], 1, false), Op::Call(122, vec![8], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(608, vec![12, 5, 6], 0, false), Op::Const(G::from_u64(0)), Op::Call(606, vec![13, 4, 15], 0, false), Op::Call(787, vec![10], 1, false), Op::Add(1, 2), Op::AssertEq(vec![16], vec![17], Some("ctor return type: wrong number of spine arguments".into())), Op::Call(607, vec![10, 1, 3, 15], 0, false), Op::Call(798, vec![10, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Store(vec![15, 5, 20]), Op::Call(620, vec![18, 21], 1, false), Op::AssertEq(vec![22], vec![15], Some("ctor return type: reflexive occurrence in an index argument".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 1, auxiliaries: 13, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_610() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Call(446, vec![5, 9, 3], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("ctor parameter type disagrees with the inductive's".into())), Op::Const(G::from_u64(0)), Op::Store(vec![14, 5, 3]), Op::Sub(2, 13), Op::Call(610, vec![6, 10, 16, 15], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_611() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(610, vec![0, 1, 2, 4], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_612() -> Function { + Function { body: Block { ops: vec![Op::Call(425, vec![0, 2], 1, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Const(G::from_u64(0)), Op::Store(vec![10, 5, 2]), Op::Call(612, vec![6, 9, 11], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_613() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Call(517, vec![4, 2], 1, false), Op::Call(331, vec![7, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], Some("ctor field lives in a universe above the inductive's".into())), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 2]), Op::Call(613, vec![5, 1, 11], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_614() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(613, vec![0, 2, 3], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Const(G::from_u64(0)), Op::Store(vec![10, 5, 3]), Op::Call(614, vec![6, 9, 2, 11], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_615() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(614, vec![0, 1, 2, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_616() -> Function { + Function { body: Block { ops: vec![Op::Call(297, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_617() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![3, 1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(617, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_618() -> Function { + Function { body: Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Call(617, vec![1, 10], 1, false)], ctrl: Ctrl::Return(0, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![15]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_619() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(2), Block { ops: vec![Op::Call(618, vec![3, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(619, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(619, vec![4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(619, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(619, vec![4, 1], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Call(619, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(619, vec![4, 1], 1, false)], ctrl: Ctrl::Return(8, vec![7]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Call(619, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(619, vec![4, 1], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(619, vec![5, 1], 1, false)], ctrl: Ctrl::Return(11, vec![8]) }))) }))) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(12, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(619, vec![5, 1], 1, false)], ctrl: Ctrl::Return(13, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 14, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_620() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(619, vec![3, 1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(620, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_621() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 2]), Op::Const(G::from_u64(1)), Op::Sub(1, 9), Op::Call(621, vec![5, 10, 8], 2, false)], ctrl: Ctrl::Return(1, vec![11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 2]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_622() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 12), Op::Sub(13, 3), Op::AssertEq(vec![9], vec![14], Some("recursive occurrence: parameter arg is not the parameter binder".into())), Op::Add(3, 12), Op::Call(622, vec![7, 1, 2, 15], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_623() -> Function { + Function { body: Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(606, vec![1, 7, 18], 0, false), Op::Call(787, vec![2], 1, false), Op::Add(9, 10), Op::AssertEq(vec![19], vec![20], Some("recursive occurrence is not fully applied".into())), Op::Call(622, vec![2, 9, 4, 18], 0, false), Op::Call(798, vec![2, 9], 1, false), Op::Call(620, vec![21, 3], 1, false), Op::AssertEq(vec![22], vec![18], Some("recursive occurrence: index argument mentions the block".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 17, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_624() -> Function { + Function { body: Block { ops: vec![Op::Call(619, vec![0, 1], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(425, vec![0, 2], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(619, vec![7, 1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![10], vec![11], Some("strict positivity: block occurs left of an arrow".into())), Op::Store(vec![11, 7, 2]), Op::Call(624, vec![8, 1, 12, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(122, vec![5], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::Call(618, vec![13, 1], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![2], 1, false), Op::Call(623, vec![13, 14, 11, 1, 17], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![13], 1, false), Op::Load(12, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(5), Block { ops: vec![Op::Call(798, vec![11, 21], 1, false), Op::Call(620, vec![30, 1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![31], vec![32], Some("strict positivity: block occurs in a nested inductive's index args".into())), Op::Store(vec![32, 25, 1]), Op::Call(797, vec![11, 21], 1, false), Op::Call(785, vec![34], 1, false), Op::Call(625, vec![25, 26, 23, 33, 32, 21, 35], 0, false)], ctrl: Ctrl::Return(4, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 35, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_625() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 4)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0, 1, 4], 1, false), Op::Load(12, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(621, vec![11, 5, 22], 2, false), Op::Const(G::from_u64(0)), Op::Call(379, vec![23, 6, 25], 1, false), Op::Call(626, vec![26, 3, 22, 25], 0, false), Op::Add(4, 21), Op::Call(625, vec![0, 1, 2, 3, 27, 5, 6], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 19, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_626() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Call(624, vec![5, 1, 2, 3], 0, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 2]), Op::Call(626, vec![6, 1, 9, 3], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_627() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 2, 6]), Op::Call(621, vec![0, 1, 3], 2, false), Op::Call(626, vec![8, 7, 9, 5], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_628() -> Function { + Function { body: Block { ops: vec![Op::Add(1, 2), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(612, vec![0, 8, 10], 1, false), Op::Const(G::from_u64(0)), Op::Call(629, vec![0, 1, 2, 3, 4, 5, 6, 11, 7, 12], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 3, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_629() -> Function { + Function { body: Block { ops: vec![Op::Sub(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![5, 6, 9], 1, false), Op::Load(12, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(6), Block { ops: vec![Op::Call(2, vec![15, 5], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![24], vec![25], Some("ctor belongs to a different block than its inductive".into())), Op::AssertEq(vec![16], vec![6], Some("ctor points at a different member of the block".into())), Op::AssertEq(vec![17], vec![9], Some("ctor's stored index differs from its position".into())), Op::AssertEq(vec![18], vec![1], Some("ctor parameter count differs from the inductive's".into())), Op::Call(611, vec![0, 14, 1], 0, false), Op::Call(609, vec![14, 18, 2, 19, 4, 5, 6], 0, false), Op::Call(615, vec![14, 18, 7], 0, false)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26]), Op::Call(627, vec![14, 18, 5, 27], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(9, 26), Op::Call(629, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 27], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 10, selectors: 4, auxiliaries: 17, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_630() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(5), Block { ops: vec![Op::Call(628, vec![2, 3, 4, 5, 1, 7, 8, 6], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_631() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![7, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(290, vec![7], 48, false)], ctrl: Ctrl::Match(14, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(632, vec![15, 2, 3, 4, 8, 62, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 4, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_632() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Sub(5, 4), Op::EqZero(54)], ctrl: Ctrl::Match(55, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 56), Op::Call(632, vec![53, 1, 2, 3, 4, 57, 6], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(297, vec![6, 5], 1, false), Op::Load(12, 56)], ctrl: Ctrl::Match(57, [(G::from_u64(5), Block { ops: vec![Op::AssertEq(vec![60], vec![2], Some("mutual block peers disagree on parameter count".into())), Op::Call(611, vec![1, 59, 2], 0, false), Op::Add(2, 3), Op::Const(G::from_u64(1)), Op::Store(vec![70, 70, 70]), Op::Call(612, vec![1, 69, 71], 1, false), Op::Add(60, 61), Op::Call(612, vec![59, 73, 71], 1, false), Op::Call(332, vec![72, 74], 1, false), Op::AssertEq(vec![75], vec![70], Some("mutual block peers land in different universes".into())), Op::Add(5, 70), Op::Call(632, vec![53, 1, 2, 3, 4, 76, 6], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 69), Op::Call(632, vec![53, 1, 2, 3, 4, 70, 6], 0, false)], ctrl: Ctrl::Return(3, vec![]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 54), Op::Call(632, vec![53, 1, 2, 3, 4, 55, 6], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 5, auxiliaries: 68, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_633() -> Function { + Function { body: Block { ops: vec![Op::Call(305, vec![0], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![17]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17]), Op::Call(634, vec![5, 9, 10, 18], 1, false)], ctrl: Ctrl::Return(5, vec![19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![17]) }))) }))) }))) }, layout: FunctionLayout { input_size: 16, selectors: 8, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_634() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Call(635, vec![0, 2, 4, 3, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 3]), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(634, vec![6, 11, 2, 9], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_635() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(122, vec![0], 2, false), Op::Call(636, vec![4, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(517, vec![7, 3], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12]), Op::Call(332, vec![10, 13], 1, false), Op::Sub(11, 14), Op::Sub(1, 11), Op::Sub(16, 2)], ctrl: Ctrl::MatchContinue(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 17, 4])], ctrl: Ctrl::Yield(2, vec![19]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 7, 3]), Op::Const(G::from_u64(1)), Op::Add(2, 21), Op::Call(635, vec![8, 1, 22, 20, 18], 1, false)], ctrl: Ctrl::Return(3, vec![23]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_636() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(637, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(636, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_637() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Sub(6, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(637, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(637, vec![4, 1], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_638() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(5), Block { ops: vec![Op::Call(639, vec![7, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(3, 4), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(612, vec![2, 14, 16], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18]), Op::Call(332, vec![17, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(298, vec![7, 8, 21], 1, false), Op::Load(12, 22)], ctrl: Ctrl::Match(23, [(G::from_u64(6), Block { ops: vec![Op::EqZero(30)], ctrl: Ctrl::Return(2, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![35]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![21]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![13]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 6, auxiliaries: 23, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_639() -> Function { + Function { body: Block { ops: vec![Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(641, vec![4, 51], 1, false)], ctrl: Ctrl::Return(1, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![51]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_640() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![49]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![49]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 50, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_641() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![49]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![49]) }))) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 49), Op::Call(641, vec![48, 50], 1, false)], ctrl: Ctrl::Return(2, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(641, vec![48, 1], 1, false)], ctrl: Ctrl::Return(3, vec![49]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 50, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_642() -> Function { + Function { body: Block { ops: vec![Op::Add(3, 4), Op::Add(2, 5), Op::Add(1, 6), Op::Call(605, vec![0, 7], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Call(122, vec![10], 2, false), Op::Load(4, 13)], ctrl: Ctrl::Match(15, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![16]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_643() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Add(3, 5), Op::Add(12, 6), Op::Add(13, 4), Op::Call(605, vec![2, 14], 1, false), Op::Load(4, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Call(122, vec![17], 2, false), Op::Load(4, 20)], ctrl: Ctrl::Match(22, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26])], ctrl: Ctrl::Return(1, vec![27]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20])], ctrl: Ctrl::Return(2, vec![21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(3, vec![13]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 4, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_644() -> Function { + Function { body: Block { ops: vec![Op::Add(3, 4), Op::Add(2, 6), Op::Add(1, 7), Op::Call(605, vec![0, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(122, vec![11], 2, false), Op::Call(797, vec![15, 5], 1, false), Op::Add(2, 3), Op::Add(17, 4), Op::Call(645, vec![16, 18], 1, false)], ctrl: Ctrl::Return(0, vec![19]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_645() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(354, vec![3, 5, 1], 1, false), Op::AssertEq(vec![6], vec![5], Some("nested occurrence's parameter references a motive, minor, or index binder".into())), Op::Call(370, vec![3, 1, 5], 1, false), Op::Call(645, vec![4, 1], 1, false), Op::Store(vec![5, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_646() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Add(0, 2), Op::Store(vec![5, 6, 4]), Op::Const(G::from_u64(1)), Op::Add(2, 8), Op::Call(646, vec![0, 1, 9], 1, false), Op::Store(vec![4, 7, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_647() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(648, vec![3, 3, 0, 1, 50], 1, false)], ctrl: Ctrl::Return(0, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 50)], ctrl: Ctrl::Match(51, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(646, vec![1, 52, 63], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![65, 65, 65]), Op::Store(vec![65, 65, 65, 65, 65, 65]), Op::Store(vec![63, 0, 63, 66, 64, 67])], ctrl: Ctrl::Return(1, vec![68]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![63, 63, 63, 63, 63, 63])], ctrl: Ctrl::Return(2, vec![64]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 67, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_648() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![52, 52, 52, 52, 52, 52])], ctrl: Ctrl::Return(0, vec![53]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(302, vec![0, 2, 4], 1, false), Op::Call(297, vec![2, 4], 1, false), Op::Load(12, 53)], ctrl: Ctrl::MatchContinue(54, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![55]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![66]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(646, vec![3, 66, 67], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![69, 69, 69]), Op::Add(4, 69), Op::Call(648, vec![0, 51, 2, 3, 71], 1, false), Op::Store(vec![67, 52, 67, 70, 68, 72])], ctrl: Ctrl::Return(3, vec![73]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 52), Op::Call(648, vec![0, 51, 2, 3, 53], 1, false)], ctrl: Ctrl::Return(4, vec![54]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 68, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_649() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(2, vec![4, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(652, vec![6, 2], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(649, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(649, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(649, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_650() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Sub(4, 8)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![11]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(335, vec![4, 8], 1, false)], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![11]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(651, vec![5, 9], 1, false)], ctrl: Ctrl::Return(6, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![11]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(3), Block { ops: vec![Op::Call(650, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(650, vec![5, 9], 1, false)], ctrl: Ctrl::Return(9, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![11]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(650, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(650, vec![5, 9], 1, false)], ctrl: Ctrl::Return(12, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(14, vec![11]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(650, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(650, vec![5, 9], 1, false)], ctrl: Ctrl::Return(15, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(16, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(17, vec![11]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(6), Block { ops: vec![Op::Call(650, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(650, vec![5, 9], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(650, vec![6, 10], 1, false)], ctrl: Ctrl::Return(18, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(19, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(20, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(21, vec![11]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(7), Block { ops: vec![Op::Call(348, vec![4, 5, 8, 9], 1, false)], ctrl: Ctrl::Return(22, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(23, vec![11]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Sub(5, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(650, vec![6, 10], 1, false)], ctrl: Ctrl::Return(24, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(25, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(26, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(27, vec![11]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 28, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_651() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(335, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(651, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_652() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(650, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(652, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_653() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Call(644, vec![2, 3, 5, 6, 4, 12], 1, false)], ctrl: Ctrl::Return(0, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_654() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(655, vec![3, 3, 0, 50, 1], 1, false)], ctrl: Ctrl::Return(0, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_655() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(302, vec![0, 2, 3], 1, false), Op::Call(295, vec![52], 1, false), Op::Load(12, 53)], ctrl: Ctrl::Match(54, [(G::from_u64(7), Block { ops: vec![Op::Call(642, vec![56, 57, 59, 60, 58], 1, false), Op::Call(295, vec![66], 1, false), Op::Load(12, 67)], ctrl: Ctrl::Match(68, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![75]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![4]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![4]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 52), Op::Call(655, vec![0, 51, 2, 53, 4], 1, false)], ctrl: Ctrl::Return(4, vec![54]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 77, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_656() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::MatchContinue(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(655, vec![4, 4, 0, 51, 1], 1, false)], ctrl: Ctrl::Yield(0, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![1]) }))) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Call(290, vec![51], 48, false)], ctrl: Ctrl::MatchContinue(52, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(52, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(648, vec![53, 53, 51, 2, 100], 1, false)], ctrl: Ctrl::Yield(2, vec![101]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(295, vec![51], 1, false), Op::Load(12, 100)], ctrl: Ctrl::Match(101, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(646, vec![2, 102, 113], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![115, 115, 115]), Op::Store(vec![115, 115, 115, 115, 115, 115]), Op::Store(vec![113, 51, 113, 116, 114, 117])], ctrl: Ctrl::Yield(3, vec![118]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![113, 113, 113, 113, 113, 113])], ctrl: Ctrl::Yield(4, vec![114]) }))) }))) })), 1, 18, 6, Box::new(Block { ops: vec![Op::Call(640, vec![0], 1, false)], ctrl: Ctrl::Match(101, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![100]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(657, vec![0, 51, 2, 100], 1, false)], ctrl: Ctrl::Return(6, vec![102]) }))) })) })) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 121, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_657() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(658, vec![5, 5, 0, 1, 2, 3, 52], 1, false)], ctrl: Ctrl::Return(0, vec![53]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 50, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_658() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(302, vec![0, 2, 6], 1, false), Op::Call(295, vec![54], 1, false), Op::Load(12, 55)], ctrl: Ctrl::MatchContinue(56, [(G::from_u64(7), Block { ops: vec![Op::Call(642, vec![58, 59, 61, 62, 60], 1, false), Op::Call(295, vec![68], 1, false), Op::Load(12, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![77, 3], 1, false)], ctrl: Ctrl::Match(82, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(1, vec![83, 68, 83, 73, 71]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(2, vec![83, 68, 83, 73, 71]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(3, vec![82, 68, 82, 82, 82]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(4, vec![68, 3, 68, 68, 68]) })), 5, 16, 4, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(68, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 73), Op::Call(658, vec![0, 53, 2, 3, 4, 5, 74], 1, false)], ctrl: Ctrl::Return(5, vec![75]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(653, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 71], 1, false), Op::Call(643, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67], 1, false), Op::Call(649, vec![5, 69, 73], 1, false)], ctrl: Ctrl::Match(75, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 76), Op::Call(658, vec![0, 53, 2, 3, 4, 5, 77], 1, false)], ctrl: Ctrl::Return(6, vec![78]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(796, vec![5, 69, 76, 73, 74], 1, false), Op::Add(6, 76), Op::Call(658, vec![0, 53, 2, 3, 4, 77, 78], 1, false)], ctrl: Ctrl::Return(7, vec![79]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 54), Op::Call(658, vec![0, 53, 2, 3, 4, 5, 55], 1, false)], ctrl: Ctrl::Return(8, vec![56]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 9, auxiliaries: 90, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_659() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 9]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![4, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 10), Op::Call(659, vec![8, 1, 11], 2, false)], ctrl: Ctrl::Return(2, vec![12, 13]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_660() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![6, 1], 1, false), Op::Sub(2, 7)], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![13]) })), 1, 1, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(1), Block { ops: vec![Op::Call(652, vec![8, 3], 1, false)], ctrl: Ctrl::Yield(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(4, vec![14]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Mul(11, 13), Op::Mul(15, 14)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![17, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 17), Op::Call(660, vec![10, 1, 2, 3, 18], 2, false)], ctrl: Ctrl::Return(6, vec![19, 20]) }))) })) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 7, auxiliaries: 17, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_661() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![9, 8, 11, 11]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(661, vec![7, 9], 4, false)], ctrl: Ctrl::Return(2, vec![10, 11, 12, 13]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_662() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Sub(6, 0), Op::Store(vec![4, 7, 4, 4])], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![3], 1, false), Op::U32LessThan(0, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(789, vec![3, 0], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Sub(8, 0), Op::Store(vec![6, 9, 6, 6])], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 11, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_663() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(662, vec![5, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(375, vec![8, 10, 11], 1, false), Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Add(5, 13), Op::Call(663, vec![12, 14, 2, 3, 4, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_664() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(664, vec![4, 8], 1, false), Op::Store(vec![6, 3, 9])], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(425, vec![0, 7], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 14), Op::Call(664, vec![11, 15], 1, false), Op::Store(vec![13, 10, 16])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(3, vec![14]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 15, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_665() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Sub(7, 3), Op::Add(8, 2), Op::Store(vec![5, 9, 5, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![11, 0, 10, 5]), Op::Add(3, 6), Op::Call(665, vec![12, 1, 2, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_666() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(366, vec![4, 2, 6], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![8, 0, 7, 6]), Op::Call(666, vec![9, 5, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_667() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(665, vec![0, 1, 2, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(666, vec![0, 4, 2], 1, false)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_668() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Sub(6, 2), Op::Store(vec![4, 7, 4, 4]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 0, 8, 4]), Op::Add(2, 5), Op::Call(668, vec![10, 1, 11], 1, false)], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_669() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(669, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_670() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(670, vec![4, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 3, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(425, vec![0, 7], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Call(670, vec![11, 14], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![17, 10, 15])], ctrl: Ctrl::Return(2, vec![18, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(3, vec![14, 0]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_671() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(366, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 8), Op::Call(671, vec![5, 1, 9], 1, false), Op::Store(vec![6, 7, 10])], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_672() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(666, vec![0, 5, 3], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(676, vec![0, 1, 2, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_673() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(1, 2), Op::Store(vec![4, 5, 4, 4]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 0, 6, 4]), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(673, vec![8, 1, 10], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_674() -> Function { + Function { body: Block { ops: vec![Op::Call(344, vec![1, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(663, vec![9, 2, 6, 7, 8, 10], 1, false), Op::Call(664, vec![11, 3], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![13, 0, 4, 10])], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(665, vec![14, 6, 3, 15], 1, false)], ctrl: Ctrl::Yield(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(666, vec![14, 8, 3], 1, false)], ctrl: Ctrl::Yield(1, vec![15]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(668, vec![15, 3, 16], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![18, 5, 16, 16]), Op::Const(G::from_u64(5)), Op::Store(vec![20, 17, 19, 16]), Op::Call(669, vec![21, 12], 1, false)], ctrl: Ctrl::Return(2, vec![22]) })) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 12, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_675() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(710, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_676() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(2, 3), Op::Store(vec![5, 6, 5, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![8, 0, 7, 5]), Op::Const(G::from_u64(1)), Op::Add(3, 10), Op::Call(676, vec![9, 1, 2, 11], 1, false)], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_677() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(677, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_678() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(661, vec![6, 9], 4, false), Op::Call(295, vec![10], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(679, vec![17, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(679, vec![0, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(1, vec![27]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 20, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_679() -> Function { + Function { body: Block { ops: vec![Op::Call(802, vec![8], 1, false), Op::Const(G::from_u64(0)), Op::Call(646, vec![7, 1, 12], 1, false), Op::Call(344, vec![0, 13], 1, false), Op::Call(670, vec![14, 4], 2, false), Op::Call(675, vec![8, 6, 4], 1, false), Op::Call(693, vec![8, 9, 4, 11, 4], 1, false), Op::Call(787, vec![18], 1, false), Op::Call(661, vec![8, 10], 4, false), Op::Call(295, vec![20], 1, false), Op::Load(12, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(5), Block { ops: vec![Op::Call(344, vec![27, 23], 1, false), Op::Const(G::from_u64(0)), Op::Call(663, vec![37, 28, 4, 21, 22, 38], 1, false), Op::Call(664, vec![39, 5], 1, false), Op::Add(11, 19), Op::Call(671, vec![40, 41, 38], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![43, 20, 23, 38]), Op::Add(4, 11), Op::Add(45, 19), Op::Add(46, 5), Op::Const(G::from_u64(1)), Op::Sub(47, 48), Op::Add(41, 5)], ctrl: Ctrl::MatchContinue(21, [(G::from_u64(1), Block { ops: vec![Op::Call(666, vec![44, 22, 50], 1, false)], ctrl: Ctrl::Yield(0, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(676, vec![44, 4, 49, 51], 1, false)], ctrl: Ctrl::Yield(1, vec![52]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(668, vec![51, 5, 52], 1, false), Op::Const(G::from_u64(1)), Op::Add(47, 54), Op::Sub(55, 54), Op::Add(4, 10), Op::Sub(56, 57), Op::Store(vec![52, 58, 52, 52]), Op::Call(673, vec![59, 5, 52], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![52, 52, 52, 52]), Op::Store(vec![61, 60, 62, 52]), Op::Const(G::from_u64(5)), Op::Store(vec![64, 53, 63, 52]), Op::Call(669, vec![65, 42], 1, false), Op::Call(669, vec![66, 18], 1, false), Op::Call(669, vec![67, 17], 1, false), Op::Call(669, vec![68, 15], 1, false)], ctrl: Ctrl::Return(2, vec![69]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 11, selectors: 3, auxiliaries: 44, lookups: 27 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_680() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::MatchContinue(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(298, vec![20, 21, 26], 1, false), Op::Load(12, 27), Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![40, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26]), Op::Store(vec![27, 28, 26, 26])], ctrl: Ctrl::Yield(1, vec![26, 26, 26, 29, 26, 26, 26, 26, 26, 26, 26, 26, 26]) })), 13, 13, 2, Box::new(Block { ops: vec![Op::Add(16, 17), Op::Const(G::from_u64(1)), Op::Store(vec![40, 40, 40]), Op::Call(612, vec![15, 39, 41], 1, false), Op::Call(639, vec![20, 25], 1, false), Op::Call(633, vec![42, 18, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 43], 1, false)], ctrl: Ctrl::MatchContinue(44, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![45, 46, 46])], ctrl: Ctrl::Yield(2, vec![47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![45, 45, 45])], ctrl: Ctrl::Yield(3, vec![46]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(713, vec![1, 46], 1, false), Op::Call(656, vec![10, 20, 44], 1, false), Op::Call(687, vec![48, 10, 12], 1, false), Op::Call(690, vec![48], 1, false), Op::Call(640, vec![10], 1, false), Op::Call(640, vec![20], 1, false), Op::Const(G::from_u64(1)), Op::Call(2, vec![10, 20], 1, false), Op::Sub(53, 54), Op::Mul(52, 55), Op::Mul(51, 56)], ctrl: Ctrl::MatchContinue(57, [(G::from_u64(1), Block { ops: vec![Op::Call(653, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16], 1, false)], ctrl: Ctrl::Yield(4, vec![58]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![58, 58, 58])], ctrl: Ctrl::Yield(5, vec![59]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(660, vec![48, 25, 57, 58, 59], 2, false)], ctrl: Ctrl::Match(60, [(G::from_u64(1), Block { ops: vec![Op::Call(681, vec![48, 61, 18, 20, 21, 3, 5, 6, 47, 49, 50, 7, 2, 15, 14, 17, 45, 44], 0, false)], ctrl: Ctrl::Return(6, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(659, vec![48, 25, 62], 2, false)], ctrl: Ctrl::Match(63, [(G::from_u64(1), Block { ops: vec![Op::Call(681, vec![48, 64, 18, 20, 21, 3, 5, 6, 47, 49, 50, 7, 2, 15, 14, 17, 45, 44], 0, false)], ctrl: Ctrl::Return(7, vec![]) })].into_iter().collect(), None) }))) })) })) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 26, selectors: 9, auxiliaries: 51, lookups: 19 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_681() -> Function { + Function { body: Block { ops: vec![Op::Call(661, vec![0, 1], 4, false), Op::Call(678, vec![13, 14, 5, 15, 16, 17, 0, 10, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23]), Op::Call(446, vec![12, 22, 24], 1, false), Op::AssertEq(vec![25], vec![23], Some("recursor's declared type is not def-eq to the canonical reconstruction".into())), Op::Call(802, vec![0], 1, false), Op::Call(693, vec![0, 10, 5, 26, 5], 1, false), Op::Call(787, vec![27], 1, false), Op::AssertEq(vec![6], vec![26], Some("recursor motive count disagrees with the canonical reconstruction".into())), Op::AssertEq(vec![7], vec![28], Some("recursor minor count disagrees with the canonical reconstruction".into())), Op::Const(G::from_u64(0)), Op::Call(682, vec![0, 1, 29], 1, false), Op::Call(683, vec![2, 30, 3, 4, 5, 6, 7, 21, 8, 0, 9, 10, 19, 20, 29], 1, false), Op::Call(684, vec![11, 31, 5, 6, 7, 3, 4, 2, 29], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 18, selectors: 1, auxiliaries: 13, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_682() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(295, vec![5], 1, false), Op::Load(12, 10)], ctrl: Ctrl::MatchContinue(11, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(3, vec![23]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 24), Op::Call(682, vec![9, 1, 25], 1, false), Op::Add(23, 26)], ctrl: Ctrl::Return(4, vec![27]) })) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 24, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_683() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16])], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![2, 3, 14], 1, false), Op::Load(12, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(6), Block { ops: vec![Op::Add(1, 14), Op::Call(686, vec![19, 29, 4, 5, 6, 23, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(14, 32), Op::Call(683, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 33], 1, false), Op::Store(vec![31, 30, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29])], ctrl: Ctrl::Return(2, vec![30]) }))) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 18, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_684() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![10], vec![8], Some("recursor rule is out of ctor order".into())), Op::U32LessThan(10, 7), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], Some("recursor rule names a ctor index out of range".into())), Op::Call(298, vec![5, 6, 10], 1, false), Op::Load(12, 16)], ctrl: Ctrl::MatchContinue(17, [(G::from_u64(6), Block { ops: vec![Op::AssertEq(vec![11], vec![24], Some("recursor rule field count differs from the ctor's".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), None, 0, 0, 0, Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Add(2, 3), Op::Add(32, 4), Op::Add(33, 11), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Call(715, vec![12, 34, 35, 37], 3, false), Op::AssertEq(vec![39], vec![34], Some("recursor rule rhs has too few binders to peel".into())), Op::Call(446, vec![38, 30, 37], 1, false), Op::AssertEq(vec![41], vec![36], Some("recursor rule rhs differs from canonical reconstruction".into())), Op::Add(8, 36), Op::Call(684, vec![13, 31, 2, 3, 4, 5, 6, 7, 42], 0, false)], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 33, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_685() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(779, vec![2, 11, 15], 1, false), Op::Store(vec![15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15]), Op::Call(779, vec![4, 16, 17], 1, false), Op::Call(779, vec![5, 16, 15], 1, false), Op::Add(6, 7), Op::Add(20, 8), Op::Add(21, 9), Op::Call(789, vec![3, 13], 1, false), Op::Sub(9, 13), Op::Call(366, vec![23, 24, 15], 1, false), Op::Add(7, 8), Op::Call(366, vec![25, 26, 9], 1, false), Op::Call(699, vec![27], 2, false), Op::Call(787, vec![28], 1, false), Op::Add(22, 30), Op::Const(G::from_u64(2)), Op::Store(vec![32, 18, 10, 15]), Op::Const(G::from_u64(1)), Op::Sub(31, 34), Op::Call(676, vec![33, 6, 35, 15], 1, false), Op::Sub(35, 6), Op::Call(676, vec![36, 7, 37, 15], 1, false), Op::Sub(37, 7), Op::Call(676, vec![38, 8, 39, 15], 1, false), Op::Store(vec![34, 34, 34]), Op::Call(425, vec![29, 41], 1, false), Op::Call(122, vec![42], 2, false), Op::Call(798, vec![44, 19], 1, false), Op::Call(263, vec![40, 45], 1, false), Op::Sub(9, 34), Op::Sub(47, 13), Op::Add(48, 30), Op::Store(vec![15, 49, 15, 15]), Op::Call(668, vec![50, 30, 15], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![52, 46, 51, 15]), Op::Call(677, vec![53, 28], 1, false), Op::Store(vec![52, 0, 54, 15]), Op::Add(11, 34), Op::Call(685, vec![55, 14, 2, 3, 4, 5, 6, 7, 8, 9, 10, 56], 1, false)], ctrl: Ctrl::Return(1, vec![57]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 2, auxiliaries: 30, lookups: 26 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_686() -> Function { + Function { body: Block { ops: vec![Op::Call(344, vec![0, 6], 1, false), Op::Call(605, vec![13, 5], 1, false), Op::Const(G::from_u64(0)), Op::Call(696, vec![14, 15], 1, false), Op::Add(2, 3), Op::Add(17, 4), Op::Add(18, 16), Op::Call(697, vec![13, 5, 5, 15, 11, 12, 15], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(709, vec![20, 8, 22, 22, 22, 15, 15], 4, false), Op::Sub(19, 21), Op::Add(17, 1), Op::Sub(27, 28), Op::Store(vec![15, 29, 15, 15]), Op::Call(703, vec![30, 16, 16, 15], 1, false), Op::Call(685, vec![31, 24, 25, 23, 9, 10, 2, 3, 4, 16, 7, 15], 1, false)], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_687() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(688, vec![1, 4, 6, 5, 2], 1, false), Op::Const(G::from_u64(0)), Op::Call(687, vec![8, 1, 2], 1, false), Op::Store(vec![10, 9, 11])], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_688() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(689, vec![6, 6, 0, 1, 2, 3, 4, 53], 1, false)], ctrl: Ctrl::Return(0, vec![54]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![4]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 50, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_689() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(302, vec![0, 2, 7], 1, false), Op::Call(295, vec![55], 1, false), Op::Load(12, 56)], ctrl: Ctrl::MatchContinue(57, [(G::from_u64(7), Block { ops: vec![Op::Call(642, vec![59, 60, 62, 63, 61], 1, false), Op::Call(295, vec![69], 1, false), Op::Load(12, 70)], ctrl: Ctrl::MatchContinue(71, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![74]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![83]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Call(2, vec![69, 3], 1, false)], ctrl: Ctrl::Match(84, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![85]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(644, vec![59, 60, 62, 63, 61, 83], 1, false), Op::Call(652, vec![85, 4], 1, false)], ctrl: Ctrl::Yield(4, vec![86]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(5, vec![85]) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(6, vec![69]) })), 1, 20, 6, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(69, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![55]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 70), Op::Call(689, vec![0, 54, 2, 3, 4, 5, 6, 71], 1, false)], ctrl: Ctrl::Return(8, vec![72]) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 55), Op::Call(689, vec![0, 54, 2, 3, 4, 5, 6, 56], 1, false)], ctrl: Ctrl::Return(9, vec![57]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 10, auxiliaries: 85, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_690() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(295, vec![2], 1, false), Op::Load(12, 7)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![20]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(690, vec![6], 1, false), Op::Store(vec![21, 20, 22])], ctrl: Ctrl::Return(3, vec![23]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 24, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_691() -> Function { + Function { body: Block { ops: vec![Op::Call(301, vec![0], 8, false), Op::Call(301, vec![1], 8, false), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(78, vec![19, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 22, 22, 22, 22], 1, false), Op::Call(24, vec![23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_692() -> Function { + Function { body: Block { ops: vec![Op::Sub(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16])], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![10, 11, 14], 1, false), Op::Load(12, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(6), Block { ops: vec![Op::Call(691, vec![11, 14, 10], 1, false), Op::Call(698, vec![29, 19, 23, 1, 2, 3, 4, 5, 6, 7, 13, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(13, 32), Op::Add(14, 32), Op::Call(692, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 33, 34], 1, false), Op::Store(vec![31, 30, 35])], ctrl: Ctrl::Return(1, vec![36]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 19, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_693() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(694, vec![0, 0, 1, 2, 3, 4, 5, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_694() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Return(0, vec![15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(295, vec![9], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(692, vec![9, 10, 11, 12, 1, 2, 3, 4, 5, 7, 22, 23, 20, 6, 27], 1, false), Op::Call(787, vec![28], 1, false), Op::Add(6, 29), Op::Const(G::from_u64(1)), Op::Add(7, 31), Op::Call(694, vec![13, 1, 2, 3, 4, 5, 30, 32], 1, false), Op::Call(786, vec![28, 33], 1, false)], ctrl: Ctrl::Return(1, vec![34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 27), Op::Call(694, vec![13, 1, 2, 3, 4, 5, 6, 28], 1, false)], ctrl: Ctrl::Return(2, vec![29]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_695() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Sub(7, 0), Op::Store(vec![5, 8, 5, 5])], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![4], 1, false), Op::U32LessThan(0, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(789, vec![4, 0], 1, false), Op::Const(G::from_u64(0)), Op::Call(366, vec![7, 2, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Sub(9, 0), Op::Store(vec![7, 10, 7, 7])], ctrl: Ctrl::Return(2, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 11, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_696() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(696, vec![4, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_697() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(695, vec![6, 2, 3, 4, 5], 1, false), Op::Const(G::from_u64(0)), Op::Call(375, vec![9, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Sub(1, 14), Op::Add(6, 14), Op::Call(697, vec![13, 15, 2, 3, 4, 5, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Call(425, vec![0, 12], 1, false), Op::Load(4, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![Op::Call(695, vec![6, 2, 3, 4, 5], 1, false), Op::Const(G::from_u64(0)), Op::Call(375, vec![16, 18, 19], 1, false), Op::Const(G::from_u64(1)), Op::Sub(1, 21), Op::Add(6, 21), Op::Call(697, vec![20, 22, 2, 3, 4, 5, 23], 1, false)], ctrl: Ctrl::Return(2, vec![24]) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 16, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_698() -> Function { + Function { body: Block { ops: vec![Op::Call(344, vec![1, 5], 1, false), Op::Add(9, 10), Op::Add(8, 14), Op::Const(G::from_u64(0)), Op::Call(697, vec![13, 2, 15, 14, 3, 4, 16], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![18, 18, 18]), Op::Call(709, vec![17, 6, 19, 19, 19, 16, 14], 4, false), Op::Call(787, vec![20], 1, false), Op::Call(787, vec![21], 1, false), Op::Add(24, 25), Op::Add(15, 26), Op::Call(122, vec![23], 2, false), Op::Call(798, vec![29, 2], 1, false), Op::Call(702, vec![30, 25, 16], 1, false), Op::Sub(27, 18), Op::Add(11, 12), Op::Sub(32, 33), Op::Store(vec![16, 34, 16, 16]), Op::Call(263, vec![35, 31], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![37, 0, 5, 16]), Op::Call(704, vec![38, 2, 8, 27, 3, 4], 1, false), Op::Call(703, vec![39, 24, 26, 16], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![41, 36, 40, 16]), Op::Call(701, vec![21, 22, 20, 7, 11, 24, 15, 16], 1, false), Op::Call(669, vec![42, 43], 1, false), Op::Call(669, vec![44, 20], 1, false)], ctrl: Ctrl::Return(0, vec![45]) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 23, lookups: 19 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_699() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(700, vec![0, 2], 2, false), Op::Call(785, vec![3], 1, false)], ctrl: Ctrl::Return(0, vec![5, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_700() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 1]), Op::Call(700, vec![4, 7], 2, false)], ctrl: Ctrl::Return(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1, 0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_701() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11])], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(779, vec![1, 7, 11], 1, false), Op::Call(779, vec![3, 12, 11], 1, false), Op::Add(5, 7), Op::Add(6, 14), Op::Call(789, vec![2, 9], 1, false), Op::Sub(5, 9), Op::Add(17, 7), Op::Call(366, vec![16, 18, 11], 1, false), Op::Call(699, vec![19], 2, false), Op::Call(787, vec![20], 1, false), Op::Add(15, 22), Op::Const(G::from_u64(1)), Op::Sub(23, 24), Op::Add(4, 12), Op::Sub(25, 26), Op::Add(6, 9), Op::Sub(25, 28), Op::Store(vec![24, 24, 24]), Op::Call(425, vec![21, 30], 1, false), Op::Call(122, vec![31], 2, false), Op::Call(798, vec![33, 13], 1, false), Op::Store(vec![11, 27, 11, 11]), Op::Call(263, vec![35, 34], 1, false), Op::Store(vec![11, 29, 11, 11]), Op::Call(668, vec![37, 22, 11], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![39, 36, 38, 11]), Op::Call(669, vec![40, 20], 1, false), Op::Add(7, 24), Op::Call(701, vec![10, 1, 2, 3, 4, 5, 6, 42], 1, false), Op::Store(vec![11, 41, 43])], ctrl: Ctrl::Return(1, vec![44]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 24, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_702() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(366, vec![4, 1, 2], 1, false), Op::Call(702, vec![5, 1, 2], 1, false), Op::Store(vec![6, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_703() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 6), Op::Sub(7, 3), Op::Store(vec![5, 8, 5, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![10, 0, 9, 5]), Op::Add(3, 6), Op::Call(703, vec![11, 1, 2, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_704() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 6), Op::Const(G::from_u64(0)), Op::Call(676, vec![0, 2, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 2), Op::Call(666, vec![0, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_705() -> Function { + Function { body: Block { ops: vec![Op::Call(706, vec![0, 1, 2], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_706() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(425, vec![0, 4], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(706, vec![8, 1, 2], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(122, vec![5], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(707, vec![1, 13, 11, 2, 16], 2, false)], ctrl: Ctrl::Return(1, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![16, 16]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_707() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![6, 1], 1, false)], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(708, vec![8, 2, 3], 1, false)], ctrl: Ctrl::Yield(2, vec![12]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Mul(11, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![14, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 14), Op::Call(707, vec![10, 1, 2, 3, 15], 2, false)], ctrl: Ctrl::Return(4, vec![16, 17]) }))) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_708() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(366, vec![4, 2, 9], 1, false), Op::Call(650, vec![10, 7], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(708, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![12]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_709() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Add(6, 5), Op::Call(705, vec![8, 1, 11], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 8, 2])], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 5, 3]), Op::Store(vec![16, 13, 4]), Op::Const(G::from_u64(1)), Op::Add(5, 19), Op::Call(709, vec![9, 1, 15, 17, 18, 20, 6], 4, false)], ctrl: Ctrl::Return(0, vec![21, 22, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 16), Op::Call(709, vec![9, 1, 15, 3, 4, 17, 6], 4, false)], ctrl: Ctrl::Return(1, vec![18, 19, 20, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(785, vec![2], 1, false), Op::Call(785, vec![3], 1, false), Op::Call(785, vec![4], 1, false)], ctrl: Ctrl::Return(2, vec![11, 12, 13, 0]) }))) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_710() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(295, vec![5], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(5), Block { ops: vec![Op::Call(674, vec![5, 13, 14, 15, 8, 1, 2, 6, 7], 1, false), Op::Const(G::from_u64(0)), Op::Call(366, vec![23, 3, 24], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 26), Op::Call(710, vec![9, 1, 2, 27], 1, false), Op::Store(vec![24, 25, 28])], ctrl: Ctrl::Return(1, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(710, vec![9, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![23]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_711() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Call(642, vec![2, 3, 5, 6, 4], 1, false), Op::Call(295, vec![13], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(640, vec![10], 1, false), Op::Call(640, vec![22], 1, false), Op::Const(G::from_u64(1)), Op::Call(2, vec![10, 22], 1, false), Op::Sub(29, 30), Op::Mul(28, 31), Op::Mul(27, 32), Op::Call(799, vec![7], 1, false), Op::AssertEq(vec![34], vec![20], Some("recursor rule count differs from the inductive's ctor count".into())), Op::Add(3, 5), Op::Add(6, 4), Op::Add(35, 36), Op::Add(37, 29), Op::Call(605, vec![2, 38], 1, false), Op::Add(5, 6), Op::Add(3, 40), Op::Call(714, vec![7, 41, 1], 0, false)], ctrl: Ctrl::MatchContinue(33, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![3], vec![18], Some("recursor parameter count differs from its inductive's".into())), Op::AssertEq(vec![4], vec![19], Some("recursor index count differs from its inductive's".into())), Op::Add(18, 19), Op::Call(712, vec![2, 3, 5, 6, 4, 42], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Call(638, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 13], 1, false), Op::AssertEq(vec![8], vec![42], Some("recursor k_flag disagrees with its inductive's K eligibility".into())), Op::Call(630, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26], 0, false), Op::Call(680, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 13], 0, false)], ctrl: Ctrl::Return(2, vec![]) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 3, auxiliaries: 24, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_712() -> Function { + Function { body: Block { ops: vec![Op::Add(3, 4), Op::Add(2, 6), Op::Add(1, 7), Op::Call(605, vec![0, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(122, vec![11], 2, false), Op::Call(787, vec![15], 1, false), Op::AssertEq(vec![16], vec![5], Some("recursor major premise has the wrong number of spine args".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_713() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Store(vec![4, 1, 3]), Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(713, vec![0, 7], 1, false), Op::Store(vec![3, 5, 8])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_714() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(1, 5), Op::Call(599, vec![6, 8, 2], 0, false), Op::Call(714, vec![7, 1, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_715() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Add(2, 8), Op::Const(G::from_u64(0)), Op::Store(vec![11, 5, 3]), Op::Call(715, vec![6, 9, 10, 12], 3, false)], ctrl: Ctrl::Return(1, vec![13, 14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 2, 3]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_716() -> Function { + Function { body: Block { ops: vec![Op::Call(594, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Call(596, vec![13, 2], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Call(599, vec![3, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Call(596, vec![13, 2], 0, false), Op::Call(596, vec![13, 3], 0, false), Op::Call(518, vec![3, 2, 16], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Call(599, vec![3, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Store(vec![14, 14, 14]), Op::Call(332, vec![17, 18], 1, false), Op::AssertEq(vec![19], vec![15], Some("theorem's type is not a Prop".into())), Op::Call(596, vec![13, 2], 0, false), Op::Call(596, vec![13, 3], 0, false), Op::Call(518, vec![3, 2, 16], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Call(599, vec![3, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Call(596, vec![13, 2], 0, false), Op::Call(596, vec![13, 3], 0, false), Op::Call(518, vec![3, 2, 16], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Call(596, vec![13, 2], 0, false), Op::Call(604, vec![12, 3, 1, 2], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Call(596, vec![13, 2], 0, false), Op::Call(593, vec![7], 0, false), Op::Call(628, vec![2, 3, 4, 5, 1, 7, 8, 6], 0, false), Op::Call(631, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Call(596, vec![13, 2], 0, false), Op::Call(297, vec![3, 4], 1, false), Op::Load(12, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(5), Block { ops: vec![Op::AssertEq(vec![6], vec![22], Some("ctor parameter count differs from its inductive's".into())), Op::Call(611, vec![21, 2, 22], 0, false), Op::Call(609, vec![2, 6, 23, 7, 20, 3, 4], 0, false), Op::Add(22, 23), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Call(612, vec![21, 31, 33], 1, false), Op::Call(615, vec![2, 6, 34], 0, false)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35]), Op::Call(627, vec![2, 6, 3, 36], 0, false)], ctrl: Ctrl::Return(6, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(599, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(517, vec![2, 16], 1, false), Op::Call(596, vec![13, 2], 0, false), Op::Call(593, vec![10], 0, false), Op::Call(711, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 9, auxiliaries: 20, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_717() -> Function { + Function { body: Block { ops: vec![Op::Call(295, vec![0], 1, false), Op::Load(12, 1), Op::Call(716, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_718() -> Function { + Function { body: Block { ops: vec![Op::Load(18, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Store(vec![19, 20, 22])], ctrl: Ctrl::Return(0, vec![23]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(19, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(718, vec![18], 1, false), Op::Store(vec![19, 20, 21])], ctrl: Ctrl::Return(1, vec![22]) }), (G::from_u64(7), Block { ops: vec![Op::Call(718, vec![2], 1, false), Op::Call(718, vec![3], 1, false), Op::Call(786, vec![19, 20], 1, false)], ctrl: Ctrl::Return(2, vec![21]) }), (G::from_u64(8), Block { ops: vec![Op::Call(718, vec![5], 1, false), Op::Call(718, vec![6], 1, false), Op::Call(786, vec![19, 20], 1, false)], ctrl: Ctrl::Return(3, vec![21]) }), (G::from_u64(9), Block { ops: vec![Op::Call(718, vec![7], 1, false), Op::Call(718, vec![8], 1, false), Op::Call(786, vec![19, 20], 1, false)], ctrl: Ctrl::Return(4, vec![21]) }), (G::from_u64(10), Block { ops: vec![Op::Call(718, vec![7], 1, false), Op::Call(718, vec![8], 1, false), Op::Call(718, vec![9], 1, false), Op::Call(786, vec![20, 21], 1, false), Op::Call(786, vec![19, 22], 1, false)], ctrl: Ctrl::Return(5, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19])], ctrl: Ctrl::Return(6, vec![20]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 26, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_719() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(718, vec![2], 1, false), Op::Call(719, vec![3], 1, false), Op::Call(786, vec![4, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_720() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![10], 1, false), Op::Call(720, vec![11], 1, false), Op::Call(786, vec![12, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_721() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![37, 37, 37])], ctrl: Ctrl::Return(0, vec![38]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![35], 1, false), Op::Call(721, vec![36], 1, false), Op::Call(786, vec![37, 38], 1, false)], ctrl: Ctrl::Return(1, vec![39]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 40, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_722() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![48, 48, 48])], ctrl: Ctrl::Return(0, vec![49]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![13], 1, false), Op::Call(718, vec![14], 1, false), Op::Call(786, vec![48, 49], 1, false), Op::Call(722, vec![47], 1, false), Op::Call(786, vec![50, 51], 1, false)], ctrl: Ctrl::Return(1, vec![52]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![28], 1, false), Op::Call(721, vec![29], 1, false), Op::Call(786, vec![48, 49], 1, false), Op::Call(722, vec![47], 1, false), Op::Call(786, vec![50, 51], 1, false)], ctrl: Ctrl::Return(2, vec![52]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![45], 1, false), Op::Call(720, vec![46], 1, false), Op::Call(786, vec![48, 49], 1, false), Op::Call(722, vec![47], 1, false), Op::Call(786, vec![50, 51], 1, false)], ctrl: Ctrl::Return(3, vec![52]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 53, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_723() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(719, vec![45], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![11], 1, false), Op::Call(718, vec![12], 1, false), Op::Call(786, vec![49, 50], 1, false), Op::Call(786, vec![48, 51], 1, false)], ctrl: Ctrl::Return(0, vec![52]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![43], 1, false), Op::Call(720, vec![44], 1, false), Op::Call(786, vec![49, 50], 1, false), Op::Call(786, vec![48, 51], 1, false)], ctrl: Ctrl::Return(1, vec![52]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![10], 1, false), Op::Call(786, vec![48, 49], 1, false)], ctrl: Ctrl::Return(2, vec![50]) }))) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(718, vec![10], 1, false), Op::Call(786, vec![48, 49], 1, false)], ctrl: Ctrl::Return(3, vec![50]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(722, vec![1], 1, false), Op::Call(786, vec![48, 49], 1, false)], ctrl: Ctrl::Return(4, vec![50]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![48]) }))) }))) }, layout: FunctionLayout { input_size: 48, selectors: 6, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_724() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(724, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_725() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(727, vec![0, 2, 2, 49], 0, false)], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(725, vec![10], 0, false)], ctrl: Ctrl::Yield(1, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(725, vec![10], 0, false)], ctrl: Ctrl::Yield(2, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(725, vec![18], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(725, vec![10], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false)], ctrl: Ctrl::Yield(5, vec![]) })), 0, 5, 2, Box::new(Block { ops: vec![Op::Call(723, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48], 1, false), Op::Const(G::from_u64(0)), Op::Call(726, vec![47, 49, 50], 0, false)], ctrl: Ctrl::Return(6, vec![]) })) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 55, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_726() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(724, vec![1, 2], 1, false)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(1), Block { ops: vec![Op::Call(725, vec![4], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Call(726, vec![5, 1, 8], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_727() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(728, vec![0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 3], 0, false), Op::Const(G::from_u64(1)), Op::Add(3, 51), Op::Call(727, vec![0, 1, 50, 52], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 48, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_728() -> Function { + Function { body: Block { ops: vec![Op::Call(302, vec![1, 0, 47], 1, false), Op::Call(295, vec![48], 1, false), Op::Load(12, 49), Op::Call(716, vec![50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 48], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 48, selectors: 1, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_729() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(52, vec![0, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 3]), Op::Call(24, vec![5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_730() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(52, vec![1, 3], 1, false), Op::Call(52, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 2, 5]), Op::Call(24, vec![7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_731() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(96, vec![2], 2, false), Op::Call(729, vec![3], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 3, 8])], ctrl: Ctrl::Return(0, vec![5, 9, 4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![4, 6, 2]) }), (G::from_u64(2), Block { ops: vec![Op::Call(731, vec![2], 3, false), Op::Call(731, vec![5], 3, false), Op::Call(730, vec![3, 6], 1, false), Op::Call(786, vec![4, 7], 1, false)], ctrl: Ctrl::Return(2, vec![9, 10, 8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_732() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(1)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(5, vec![33, 34, 35], 1, false), Op::Call(83, vec![36], 10, false), Op::Const(G::from_u64(14)), Op::AssertEq(vec![37], vec![47], Some("assumption tree: wrong tag4 flag".into())), Op::Const(G::from_u64(2)), Op::AssertEq(vec![38], vec![48], Some("assumption tree: wrong tag4 variant".into())), Op::Call(731, vec![46], 3, false), Op::Load(3, 51), Op::AssertEq(vec![52, 53, 54], vec![33, 33, 33], Some("assumption tree: trailing bytes after tree body".into())), Op::Load(32, 49), Op::AssertEq(vec![55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86], vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], Some("assumption tree: recomputed merkle root != requested root".into()))], ctrl: Ctrl::Return(0, vec![50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 84, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_733() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(801, vec![8, 10, 1, 2, 3, 4, 5, 6], 6, false), Op::Call(733, vec![9, 11, 12, 13, 14, 15, 16], 6, false)], ctrl: Ctrl::Return(1, vec![17, 18, 19, 20, 21, 22]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_734() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(784, vec![0, 1, 2, 3, 4, 5, 6, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 7, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_735() -> Function { + Function { body: Block { ops: vec![Op::Call(734, vec![0, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(13, [(G::from_u64(1), Block { ops: vec![Op::Call(734, vec![0, 1, 2, 3, 4, 5, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![15], vec![16], Some("CheckEnv: walk reached a constant outside the owned set".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(15, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(727, vec![0, 16, 16, 63], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(735, vec![24, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(735, vec![24, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(5, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(735, vec![32, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(6, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Call(735, vec![24, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(7, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false)], ctrl: Ctrl::Yield(8, vec![]) })), 0, 5, 2, Box::new(Block { ops: vec![Op::Call(723, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62], 1, false), Op::Const(G::from_u64(0)), Op::Call(736, vec![61, 63, 64, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Return(9, vec![]) })) }))) })) }))) }, layout: FunctionLayout { input_size: 14, selectors: 10, auxiliaries: 58, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_736() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(724, vec![1, 2], 1, false)], ctrl: Ctrl::MatchContinue(19, [(G::from_u64(1), Block { ops: vec![Op::Call(735, vec![17, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 20), Op::Call(736, vec![18, 1, 21, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 4, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_737() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(735, vec![14, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 16], 0, false), Op::Call(737, vec![15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_738() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Call(732, vec![0], 1, false), Op::Call(739, vec![3], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(732, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::Call(733, vec![3, 4, 4, 4, 4, 4, 4], 6, false), Op::Call(732, vec![2], 1, false), Op::Call(733, vec![11, 4, 4, 4, 4, 4, 4], 6, false), Op::Call(737, vec![3, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_739() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 2), Op::Call(740, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 0, false), Op::Call(739, vec![3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 36, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_740() -> Function { + Function { body: Block { ops: vec![Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Call(741, vec![32], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_741() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(727, vec![0, 2, 2, 49], 0, false)], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Load(32, 10), Op::Call(740, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(1, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Load(32, 10), Op::Call(740, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(2, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Load(32, 18), Op::Call(740, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false), Op::Load(32, 10), Op::Call(740, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(717, vec![0], 0, false)], ctrl: Ctrl::Yield(5, vec![]) })), 0, 32, 3, Box::new(Block { ops: vec![Op::Call(723, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48], 1, false), Op::Const(G::from_u64(0)), Op::Call(742, vec![47, 49, 50], 0, false)], ctrl: Ctrl::Return(6, vec![]) })) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 82, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_742() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(724, vec![1, 2], 1, false)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(1), Block { ops: vec![Op::Load(32, 4), Op::Call(740, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 32, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Call(742, vec![5, 1, 8], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 37, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_743() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(96, vec![2], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_744() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(81, vec![1], 9, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_745() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(96, vec![1], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 2, 3]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_746() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(79, vec![1], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 2, 3]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_747() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(79, vec![1], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 4, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![4, 5, 3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![4, 5, 3]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_748() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(79, vec![1], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 4, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![4, 5, 3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![4, 5, 3]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(4, vec![4, 5, 3]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_749() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(116, vec![0], 18, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(749, vec![27, 28, 29, 30, 31, 32, 33, 34, 35], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![38, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 36])], ctrl: Ctrl::Return(1, vec![39, 37]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 32, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_750() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(81, vec![1], 9, false), Op::Call(749, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13, 11, 12]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_751() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::U8BitDecomposition(1), Op::Call(746, vec![10, 9], 3, false), Op::Call(744, vec![11, 20], 10, false), Op::Call(744, vec![12, 30], 10, false), Op::Call(744, vec![13, 40], 10, false), Op::Call(744, vec![14, 50], 10, false), Op::Call(745, vec![15, 60], 3, false)], ctrl: Ctrl::Return(0, vec![18, 19, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 64, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_752() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(751, vec![9], 41, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_753() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(752, vec![0], 49, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(753, vec![58, 59, 60, 61, 62, 63, 64, 65, 66], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![69, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 67])], ctrl: Ctrl::Return(1, vec![70, 68]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 63, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_754() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(81, vec![1], 9, false), Op::Call(753, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13, 11, 12]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_755() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Call(81, vec![2], 9, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(747, vec![12, 11], 3, false), Op::Call(747, vec![13, 30], 3, false), Op::Call(744, vec![14, 33], 10, false), Op::Call(745, vec![15, 43], 3, false), Op::Call(745, vec![16, 46], 3, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![50, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 47, 48, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 49]) }), (G::from_u64(1), Block { ops: vec![Op::Call(746, vec![12, 11], 3, false), Op::Call(744, vec![13, 30], 10, false), Op::Call(744, vec![14, 40], 10, false), Op::Call(744, vec![15, 50], 10, false), Op::Call(745, vec![16, 60], 3, false), Op::Call(754, vec![17, 63], 3, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![67, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 65, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 66]) }), (G::from_u64(2), Block { ops: vec![Op::Call(746, vec![12, 11], 3, false), Op::Call(746, vec![13, 30], 3, false), Op::Call(744, vec![14, 33], 10, false), Op::Call(744, vec![15, 43], 10, false), Op::Call(744, vec![16, 53], 10, false), Op::Call(744, vec![17, 63], 10, false), Op::Call(744, vec![18, 73], 10, false), Op::Call(745, vec![19, 83], 3, false), Op::Call(750, vec![20, 86], 3, false), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![90, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, 69, 70, 71, 72, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 87, 88, 89]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 90, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_756() -> Function { + Function { body: Block { ops: vec![Op::Call(81, vec![0], 9, false), Op::Call(755, vec![9], 55, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 65, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_757() -> Function { + Function { body: Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(756, vec![0], 63, false), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(757, vec![72, 73, 74, 75, 76, 77, 78, 79, 80], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![83, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 81])], ctrl: Ctrl::Return(1, vec![84, 82]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 77, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_758() -> Function { + Function { body: Block { ops: vec![Op::Call(79, vec![0], 2, false), Op::Call(81, vec![2], 9, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(747, vec![12, 11], 3, false), Op::Call(747, vec![13, 30], 3, false), Op::Call(744, vec![14, 33], 10, false), Op::Call(745, vec![15, 43], 3, false), Op::Call(745, vec![16, 46], 3, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![50, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 47, 48, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 49]) }), (G::from_u64(1), Block { ops: vec![Op::Call(746, vec![12, 11], 3, false), Op::Call(746, vec![13, 30], 3, false), Op::Call(744, vec![14, 33], 10, false), Op::Call(744, vec![15, 43], 10, false), Op::Call(744, vec![16, 53], 10, false), Op::Call(744, vec![17, 63], 10, false), Op::Call(744, vec![18, 73], 10, false), Op::Call(745, vec![19, 83], 3, false), Op::Call(750, vec![20, 86], 3, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![90, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, 69, 70, 71, 72, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 87, 88, 89]) }), (G::from_u64(2), Block { ops: vec![Op::Call(746, vec![12, 11], 3, false), Op::Call(744, vec![13, 30], 10, false), Op::Call(745, vec![14, 40], 3, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![44, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 43]) }), (G::from_u64(3), Block { ops: vec![Op::Call(748, vec![12, 11], 3, false), Op::Call(744, vec![13, 30], 10, false), Op::Call(745, vec![14, 40], 3, false), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![44, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 43]) }), (G::from_u64(4), Block { ops: vec![Op::Call(744, vec![12, 11], 10, false), Op::Call(744, vec![13, 37], 10, false), Op::Call(745, vec![14, 47], 3, false), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 40, 41, 42, 43, 44, 45, 46, 48, 49, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 50]) }), (G::from_u64(5), Block { ops: vec![Op::Call(744, vec![12, 11], 10, false), Op::Call(745, vec![13, 37], 3, false), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![41, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 40]) }), (G::from_u64(6), Block { ops: vec![Op::Call(744, vec![12, 11], 10, false), Op::Call(745, vec![13, 37], 3, false), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![41, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 40]) }), (G::from_u64(7), Block { ops: vec![Op::Call(744, vec![12, 11], 10, false), Op::Call(745, vec![13, 37], 3, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![41, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 40]) }), (G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28])], ctrl: Ctrl::Yield(8, vec![29, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(81, vec![11], 9, false), Op::Call(757, vec![36, 28, 29, 30, 31, 32, 33, 34, 35], 2, false)], ctrl: Ctrl::Yield(9, vec![37, 38]) })].into_iter().collect(), None, 2, 11, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![30, 28, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 29]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 11, auxiliaries: 90, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_759() -> Function { + Function { body: Block { ops: vec![Op::Load(18, 0), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Call(36, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20], 1, false), Op::Call(24, vec![21], 1, false)], ctrl: Ctrl::Return(0, vec![22]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 22, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_760() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_761() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(760, vec![0], 1, false), Op::Call(760, vec![2], 1, false), Op::AssertEq(vec![3], vec![4], Some("Reveal: claimed definition kind != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_762() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(760, vec![0], 1, false), Op::Call(760, vec![2], 1, false), Op::AssertEq(vec![3], vec![4], Some("Reveal: claimed definition safety != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_763() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(110, vec![0], 1, false), Op::Call(110, vec![2], 1, false), Op::AssertEq(vec![3], vec![4], Some("Reveal: claimed quotient kind != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_764() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![0], vec![2], Some("Reveal: claimed flag != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_765() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![0, 1, 2, 3, 4, 5, 6, 7], vec![9, 10, 11, 12, 13, 14, 15, 16], Some("Reveal: claimed numeric field != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 17, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_766() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 0), Op::Load(32, 2), Op::AssertEq(vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34], vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66], Some("Reveal: claimed address field != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 65, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_767() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(759, vec![0], 1, false), Op::Load(32, 3), Op::Load(32, 2), Op::AssertEq(vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], vec![36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67], Some("Reveal: claimed expr hash != hash of the real expr".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 66, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_768() -> Function { + Function { body: Block { ops: vec![Op::Load(19, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(29, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(30, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![11, 12, 13, 14, 15, 16, 17, 18], vec![2, 3, 4, 5, 6, 7, 8, 9], Some("Reveal: claimed recursor rule index != its position".into())), Op::AssertEq(vec![30, 31, 32, 33, 34, 35, 36, 37], vec![19, 20, 21, 22, 23, 24, 25, 26], Some("Reveal: claimed recursor rule field count != real".into())), Op::Const(G::from_u64(0)), Op::Call(767, vec![38, 40, 27], 0, false), Op::Call(17, vec![2, 3, 4, 5, 6, 7, 8, 9], 8, false), Op::Call(768, vec![39, 28, 41, 42, 43, 44, 45, 46, 47, 48], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 39, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_769() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![0, 2, 3, 3, 3, 3, 3, 3, 3, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 1, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_770() -> Function { + Function { body: Block { ops: vec![Op::Call(794, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 34, false)], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(49, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![49, 9, 10], 0, false), Op::Call(765, vec![50, 51, 52, 53, 54, 55, 56, 57, 11, 12, 13, 14, 15, 16, 17, 18, 19], 0, false), Op::Call(765, vec![58, 59, 60, 61, 62, 63, 64, 65, 20, 21, 22, 23, 24, 25, 26, 27, 28], 0, false), Op::Call(765, vec![66, 67, 68, 69, 70, 71, 72, 73, 29, 30, 31, 32, 33, 34, 35, 36, 37], 0, false), Op::Call(765, vec![74, 75, 76, 77, 78, 79, 80, 81, 38, 39, 40, 41, 42, 43, 44, 45, 46], 0, false), Op::Call(767, vec![82, 47, 48], 0, false)], ctrl: Ctrl::Return(0, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 49, selectors: 1, auxiliaries: 35, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_771() -> Function { + Function { body: Block { ops: vec![Op::Load(50, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(770, vec![0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50], 0, false), Op::Call(771, vec![0, 51], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 51, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_772() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(771, vec![0, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 1, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_773() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(45, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(761, vec![1, 46, 47], 0, false), Op::Call(762, vec![2, 48, 49], 0, false), Op::Call(765, vec![3, 4, 5, 6, 7, 8, 9, 10, 50, 51, 52, 53, 54, 55, 56, 57, 58], 0, false), Op::Call(767, vec![11, 59, 60], 0, false), Op::Call(767, vec![12, 61, 62], 0, false)], ctrl: Ctrl::Return(0, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(45, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![1, 46, 47], 0, false), Op::Call(765, vec![2, 3, 4, 5, 6, 7, 8, 9, 48, 49, 50, 51, 52, 53, 54, 55, 56], 0, false), Op::Call(765, vec![10, 11, 12, 13, 14, 15, 16, 17, 57, 58, 59, 60, 61, 62, 63, 64, 65], 0, false), Op::Call(765, vec![18, 19, 20, 21, 22, 23, 24, 25, 66, 67, 68, 69, 70, 71, 72, 73, 74], 0, false), Op::Call(767, vec![26, 75, 76], 0, false), Op::Call(772, vec![27, 77, 78], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(45, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![1, 46, 47], 0, false), Op::Call(764, vec![2, 48, 49], 0, false), Op::Call(765, vec![3, 4, 5, 6, 7, 8, 9, 10, 50, 51, 52, 53, 54, 55, 56, 57, 58], 0, false), Op::Call(765, vec![11, 12, 13, 14, 15, 16, 17, 18, 59, 60, 61, 62, 63, 64, 65, 66, 67], 0, false), Op::Call(765, vec![19, 20, 21, 22, 23, 24, 25, 26, 68, 69, 70, 71, 72, 73, 74, 75, 76], 0, false), Op::Call(765, vec![27, 28, 29, 30, 31, 32, 33, 34, 77, 78, 79, 80, 81, 82, 83, 84, 85], 0, false), Op::Call(765, vec![35, 36, 37, 38, 39, 40, 41, 42, 86, 87, 88, 89, 90, 91, 92, 93, 94], 0, false), Op::Call(767, vec![43, 95, 96], 0, false), Op::Call(769, vec![44, 97, 98], 0, false)], ctrl: Ctrl::Return(2, vec![]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 99, selectors: 3, auxiliaries: 1, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_774() -> Function { + Function { body: Block { ops: vec![Op::Load(64, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(791, vec![0, 3, 4, 5, 6, 7, 8, 9, 10], 45, false), Op::Call(773, vec![66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64], 0, false), Op::Call(774, vec![0, 65], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 110, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_775() -> Function { + Function { body: Block { ops: vec![Op::Call(290, vec![0], 48, false)], ctrl: Ctrl::Match(55, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(761, vec![56, 2, 3], 0, false), Op::Call(762, vec![57, 4, 5], 0, false), Op::Call(765, vec![58, 59, 60, 61, 62, 63, 64, 65, 6, 7, 8, 9, 10, 11, 12, 13, 14], 0, false), Op::Call(767, vec![66, 15, 16], 0, false), Op::Call(767, vec![67, 17, 18], 0, false)], ctrl: Ctrl::Return(0, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![56, 2, 3], 0, false), Op::Call(764, vec![57, 4, 5], 0, false), Op::Call(765, vec![58, 59, 60, 61, 62, 63, 64, 65, 6, 7, 8, 9, 10, 11, 12, 13, 14], 0, false), Op::Call(765, vec![66, 67, 68, 69, 70, 71, 72, 73, 15, 16, 17, 18, 19, 20, 21, 22, 23], 0, false), Op::Call(765, vec![74, 75, 76, 77, 78, 79, 80, 81, 24, 25, 26, 27, 28, 29, 30, 31, 32], 0, false), Op::Call(765, vec![82, 83, 84, 85, 86, 87, 88, 89, 33, 34, 35, 36, 37, 38, 39, 40, 41], 0, false), Op::Call(765, vec![90, 91, 92, 93, 94, 95, 96, 97, 42, 43, 44, 45, 46, 47, 48, 49, 50], 0, false), Op::Call(767, vec![98, 51, 52], 0, false), Op::Call(769, vec![99, 53, 54], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![56, 2, 3], 0, false), Op::Call(765, vec![57, 58, 59, 60, 61, 62, 63, 64, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false), Op::Call(767, vec![65, 13, 14], 0, false)], ctrl: Ctrl::Return(2, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(763, vec![56, 2, 3], 0, false), Op::Call(765, vec![57, 58, 59, 60, 61, 62, 63, 64, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false), Op::Call(767, vec![65, 13, 14], 0, false)], ctrl: Ctrl::Return(3, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(765, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(765, vec![64, 65, 66, 67, 68, 69, 70, 71, 11, 12, 13, 14, 15, 16, 17, 18, 19], 0, false), Op::Call(766, vec![72, 20, 21], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(765, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(766, vec![64, 11, 12], 0, false)], ctrl: Ctrl::Return(5, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(765, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(766, vec![64, 11, 12], 0, false)], ctrl: Ctrl::Return(6, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(765, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(766, vec![64, 11, 12], 0, false)], ctrl: Ctrl::Return(7, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(8), Block { ops: vec![Op::Call(774, vec![56, 2], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 55, selectors: 9, auxiliaries: 49, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_776() -> Function { + Function { body: Block { ops: vec![Op::Call(732, vec![0], 1, false), Op::Call(424, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![4], Some("Contains: target is not a leaf of the claimed tree".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_777() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(8, vec![0, 1, 2, 3, 4, 5, 6, 7]), Op::Call(5, vec![8, 9, 10], 1, false), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![43, 43, 43]), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8]), Op::Store(vec![12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42]), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Call(27, vec![11, 44, 8, 8, 45, 46, 47], 1, false), Op::Call(26, vec![48], 32, false), Op::Const(G::from_u64(256)), Op::Mul(81, 50), Op::Const(G::from_u64(65536)), Op::Mul(83, 51), Op::Const(G::from_u64(16777216)), Op::Mul(85, 52), Op::Add(84, 86), Op::Add(82, 87), Op::Add(49, 88), Op::Mul(81, 54), Op::Mul(83, 55), Op::Mul(85, 56), Op::Add(91, 92), Op::Add(90, 93), Op::Add(53, 94), Op::Mul(81, 58), Op::Mul(83, 59), Op::Mul(85, 60), Op::Add(97, 98), Op::Add(96, 99), Op::Add(57, 100), Op::Mul(81, 62), Op::Mul(83, 63), Op::Mul(85, 64), Op::Add(103, 104), Op::Add(102, 105), Op::Add(61, 106), Op::Mul(81, 66), Op::Mul(83, 67), Op::Mul(85, 68), Op::Add(109, 110), Op::Add(108, 111), Op::Add(65, 112), Op::Mul(81, 70), Op::Mul(83, 71), Op::Mul(85, 72), Op::Add(115, 116), Op::Add(114, 117), Op::Add(69, 118), Op::Mul(81, 74), Op::Mul(83, 75), Op::Mul(85, 76), Op::Add(121, 122), Op::Add(120, 123), Op::Add(73, 124), Op::Mul(81, 78), Op::Mul(83, 79), Op::Mul(85, 80), Op::Add(127, 128), Op::Add(126, 129), Op::Add(77, 130), Op::AssertEq(vec![89, 95, 101, 107, 113, 119, 125, 131], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("claim: bytes do not hash to the public claim digest".into())), Op::Call(83, vec![11], 10, false), Op::AssertEq(vec![132], vec![29], Some("claim: wrong tag4 flag".into())), Op::Add(134, 135), Op::Add(142, 136), Op::Add(143, 137), Op::Add(144, 138), Op::Add(145, 139), Op::Add(146, 140), Op::AssertEq(vec![147], vec![8], Some("claim: tag4 size exceeds a single byte".into())), Op::Call(79, vec![141], 2, false), Op::Const(G::from_u64(3)), Op::AssertEq(vec![148], vec![150], Some("claim: unsupported object format".into())), Op::Call(79, vec![149], 2, false)], ctrl: Ctrl::Match(133, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(96, vec![152], 2, false), Op::Call(743, vec![155], 3, false), Op::Load(3, 158), Op::AssertEq(vec![159, 160, 161], vec![153, 153, 153], Some("claim: trailing bytes".into()))], ctrl: Ctrl::Match(156, [(G::from_u64(1), Block { ops: vec![Op::Call(725, vec![154], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(732, vec![157], 1, false), Op::Const(G::from_u64(1)), Op::Call(733, vec![162, 163, 163, 163, 163, 163, 163], 6, false), Op::Const(G::from_u64(0)), Op::Call(735, vec![154, 163, 163, 163, 163, 163, 163, 164, 165, 166, 167, 168, 169, 170], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(96, vec![152], 2, false), Op::Call(743, vec![155], 3, false), Op::Load(3, 158), Op::AssertEq(vec![159, 160, 161], vec![153, 153, 153], Some("claim: trailing bytes".into())), Op::Call(738, vec![154, 156, 157], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(96, vec![152], 2, false), Op::Call(758, vec![155], 55, false), Op::Load(3, 210), Op::Const(G::from_u64(1)), Op::AssertEq(vec![211, 212, 213], vec![214, 214, 214], Some("claim: trailing bytes".into())), Op::Call(775, vec![154, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(96, vec![152], 2, false), Op::Call(96, vec![155], 2, false), Op::Load(3, 157), Op::Const(G::from_u64(1)), Op::AssertEq(vec![158, 159, 160], vec![161, 161, 161], Some("claim: trailing bytes".into())), Op::Call(776, vec![154, 156], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(2)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong resource validator identity".into())), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![154], vec![155], Some("claim: resource-v1 is not implemented by IxVM".into()))], ctrl: Ctrl::Return(5, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 6, auxiliaries: 115, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_778() -> Function { + Function { body: Block { ops: vec![Op::Call(777, vec![0, 1, 2, 3, 4, 5, 6, 7], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_779() -> Function { + Function { body: Block { ops: vec![Op::Call(798, vec![0, 1], 1, false), Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_780() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![5, 1, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(780, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_781() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11, 11, 11, 11, 11, 11, 11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(781, vec![10], 8, false), Op::Call(17, vec![11, 12, 13, 14, 15, 16, 17, 18], 8, false)], ctrl: Ctrl::Return(1, vec![19, 20, 21, 22, 23, 24, 25, 26]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 27, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_782() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(782, vec![5, 1], 1, false), Op::Store(vec![6, 3, 4, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_783() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 4, 4, 4, 4, 4, 4, 4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(783, vec![3], 8, false), Op::Call(17, vec![4, 5, 6, 7, 8, 9, 10, 11], 8, false)], ctrl: Ctrl::Return(1, vec![12, 13, 14, 15, 16, 17, 18, 19]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 20, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_784() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 5), Op::Load(6, 6), Op::U32LessThan(0, 3)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(784, vec![0, 8, 9, 10, 11, 12, 13, 7], 1, false)], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(0, 3)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(784, vec![0, 14, 15, 16, 17, 18, 19, 7], 1, false)], ctrl: Ctrl::Return(3, vec![22]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 22, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_785() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(803, vec![0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_786() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(786, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_787() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(787, vec![3], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 5)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_788() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![37, 37, 37, 37, 37, 37, 37, 37]) }), (G::from_u64(0), Block { ops: vec![Op::Call(788, vec![36], 8, false), Op::Call(17, vec![37, 38, 39, 40, 41, 42, 43, 44], 8, false)], ctrl: Ctrl::Return(1, vec![45, 46, 47, 48, 49, 50, 51, 52]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 53, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_789() -> Function { + Function { body: Block { ops: vec![Op::Call(798, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_790() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(790, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Add(11, 12)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_791() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(56, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54]) }), (G::from_u64(0), Block { ops: vec![Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(791, vec![55, 57, 58, 59, 60, 61, 62, 63, 64], 45, false)], ctrl: Ctrl::Return(1, vec![65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 102, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_792() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![48, 48, 48, 48, 48, 48, 48, 48]) }), (G::from_u64(0), Block { ops: vec![Op::Call(792, vec![47], 8, false), Op::Call(17, vec![48, 49, 50, 51, 52, 53, 54, 55], 8, false)], ctrl: Ctrl::Return(1, vec![56, 57, 58, 59, 60, 61, 62, 63]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 64, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_793() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 12, 12, 12, 12, 12, 12, 12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(793, vec![11], 8, false), Op::Call(17, vec![12, 13, 14, 15, 16, 17, 18, 19], 8, false)], ctrl: Ctrl::Return(1, vec![20, 21, 22, 23, 24, 25, 26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_794() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(7, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(45, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43]) }), (G::from_u64(0), Block { ops: vec![Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(794, vec![44, 46, 47, 48, 49, 50, 51, 52, 53], 34, false)], ctrl: Ctrl::Return(1, vec![54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 80, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_795() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_796() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12]), Op::Store(vec![11, 1, 2, 3, 4, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(796, vec![10, 1, 2, 3, 4], 1, false), Op::Store(vec![11, 6, 7, 8, 9, 12])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_797() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(797, vec![4, 7], 1, false), Op::Store(vec![5, 3, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_798() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(798, vec![0, 3], 1, false), Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_799() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(799, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_800() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(800, vec![3], 1, false), Op::Call(3, vec![4], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_801() -> Function { + Function { body: Block { ops: vec![Op::Call(804, vec![0, 1, 2, 3, 4, 5, 6, 7], 6, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![14, 15, 10, 11, 12, 13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 7, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_802() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(802, vec![6], 1, false), Op::Const(G::from_u64(1)), Op::Add(7, 8)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_803() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 1]), Op::Call(803, vec![4, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_804() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![8, 8, 0, 1, 10, 10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6), Op::Load(6, 7), Op::U32LessThan(0, 4)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(804, vec![0, 1, 8, 9, 10, 11, 12, 13], 6, false), Op::Call(805, vec![3, 4, 5, 21, 22, 23, 24, 25, 26, 14, 15, 16, 17, 18, 19], 6, false)], ctrl: Ctrl::Return(1, vec![27, 28, 29, 30, 31, 32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(0, 4)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![14, 15, 16, 17, 18, 19])], ctrl: Ctrl::Return(2, vec![22, 3, 0, 1, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(804, vec![0, 1, 14, 15, 16, 17, 18, 19], 6, false), Op::Call(805, vec![3, 4, 5, 8, 9, 10, 11, 12, 13, 22, 23, 24, 25, 26, 27], 6, false)], ctrl: Ctrl::Return(3, vec![28, 29, 30, 31, 32, 33]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 33, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_805() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Call(806, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 6, false)], ctrl: Ctrl::Return(0, vec![15, 16, 17, 18, 19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![3, 4, 5, 6, 7, 8]), Op::Store(vec![9, 10, 11, 12, 13, 14])], ctrl: Ctrl::Return(1, vec![15, 0, 1, 2, 16, 17]) }))) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_806() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 21, 16, 17, 18, 19]), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![20, 21, 0, 1, 7, 23])], ctrl: Ctrl::Return(0, vec![20, 20, 4, 5, 22, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 7)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 27, 4, 5, 6, 24]), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![26, 27, 0, 1, 25, 29])], ctrl: Ctrl::Return(1, vec![26, 26, 22, 23, 28, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(2, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(3, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(4, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(5, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(6, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(7, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(8, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(9, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(10, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(11, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(12, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(13, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(14, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(15, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(16, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(17, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(18, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(19, vec![26, 27, 0, 1, 28, 29]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 7)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 27, 4, 5, 6, 24]), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![26, 27, 0, 1, 25, 29])], ctrl: Ctrl::Return(20, vec![26, 26, 22, 23, 28, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(21, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(22, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(23, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(24, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(25, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(26, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(27, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(28, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(29, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(30, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(31, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(32, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(33, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(34, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(35, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(36, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(37, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(38, vec![26, 27, 0, 1, 28, 29]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![20, 21, 0, 1, 22, 18]), Op::Store(vec![20, 21, 10, 11, 19, 13])], ctrl: Ctrl::Return(39, vec![20, 20, 16, 17, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(40, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(41, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(42, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(43, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(44, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(45, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(46, vec![14, 15, 0, 1, 16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(47, vec![14, 15, 0, 1, 16, 17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![20, 21, 0, 1, 22, 18]), Op::Store(vec![20, 21, 10, 11, 19, 13])], ctrl: Ctrl::Return(48, vec![20, 20, 16, 17, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(49, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(50, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(51, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(52, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(53, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(54, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(55, vec![14, 15, 0, 1, 16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(56, vec![14, 15, 0, 1, 16, 17]) }))) }))) }, layout: FunctionLayout { input_size: 14, selectors: 57, auxiliaries: 31, lookups: 8 }, entry: false, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21(), expected_function_22(), expected_function_23(), expected_function_24(), expected_function_25(), expected_function_26(), expected_function_27(), expected_function_28(), expected_function_29(), expected_function_30(), expected_function_31(), expected_function_32(), expected_function_33(), expected_function_34(), expected_function_35(), expected_function_36(), expected_function_37(), expected_function_38(), expected_function_39(), expected_function_40(), expected_function_41(), expected_function_42(), expected_function_43(), expected_function_44(), expected_function_45(), expected_function_46(), expected_function_47(), expected_function_48(), expected_function_49(), expected_function_50(), expected_function_51(), expected_function_52(), expected_function_53(), expected_function_54(), expected_function_55(), expected_function_56(), expected_function_57(), expected_function_58(), expected_function_59(), expected_function_60(), expected_function_61(), expected_function_62(), expected_function_63(), expected_function_64(), expected_function_65(), expected_function_66(), expected_function_67(), expected_function_68(), expected_function_69(), expected_function_70(), expected_function_71(), expected_function_72(), expected_function_73(), expected_function_74(), expected_function_75(), expected_function_76(), expected_function_77(), expected_function_78(), expected_function_79(), expected_function_80(), expected_function_81(), expected_function_82(), expected_function_83(), expected_function_84(), expected_function_85(), expected_function_86(), expected_function_87(), expected_function_88(), expected_function_89(), expected_function_90(), expected_function_91(), expected_function_92(), expected_function_93(), expected_function_94(), expected_function_95(), expected_function_96(), expected_function_97(), expected_function_98(), expected_function_99(), expected_function_100(), expected_function_101(), expected_function_102(), expected_function_103(), expected_function_104(), expected_function_105(), expected_function_106(), expected_function_107(), expected_function_108(), expected_function_109(), expected_function_110(), expected_function_111(), expected_function_112(), expected_function_113(), expected_function_114(), expected_function_115(), expected_function_116(), expected_function_117(), expected_function_118(), expected_function_119(), expected_function_120(), expected_function_121(), expected_function_122(), expected_function_123(), expected_function_124(), expected_function_125(), expected_function_126(), expected_function_127(), expected_function_128(), expected_function_129(), expected_function_130(), expected_function_131(), expected_function_132(), expected_function_133(), expected_function_134(), expected_function_135(), expected_function_136(), expected_function_137(), expected_function_138(), expected_function_139(), expected_function_140(), expected_function_141(), expected_function_142(), expected_function_143(), expected_function_144(), expected_function_145(), expected_function_146(), expected_function_147(), expected_function_148(), expected_function_149(), expected_function_150(), expected_function_151(), expected_function_152(), expected_function_153(), expected_function_154(), expected_function_155(), expected_function_156(), expected_function_157(), expected_function_158(), expected_function_159(), expected_function_160(), expected_function_161(), expected_function_162(), expected_function_163(), expected_function_164(), expected_function_165(), expected_function_166(), expected_function_167(), expected_function_168(), expected_function_169(), expected_function_170(), expected_function_171(), expected_function_172(), expected_function_173(), expected_function_174(), expected_function_175(), expected_function_176(), expected_function_177(), expected_function_178(), expected_function_179(), expected_function_180(), expected_function_181(), expected_function_182(), expected_function_183(), expected_function_184(), expected_function_185(), expected_function_186(), expected_function_187(), expected_function_188(), expected_function_189(), expected_function_190(), expected_function_191(), expected_function_192(), expected_function_193(), expected_function_194(), expected_function_195(), expected_function_196(), expected_function_197(), expected_function_198(), expected_function_199(), expected_function_200(), expected_function_201(), expected_function_202(), expected_function_203(), expected_function_204(), expected_function_205(), expected_function_206(), expected_function_207(), expected_function_208(), expected_function_209(), expected_function_210(), expected_function_211(), expected_function_212(), expected_function_213(), expected_function_214(), expected_function_215(), expected_function_216(), expected_function_217(), expected_function_218(), expected_function_219(), expected_function_220(), expected_function_221(), expected_function_222(), expected_function_223(), expected_function_224(), expected_function_225(), expected_function_226(), expected_function_227(), expected_function_228(), expected_function_229(), expected_function_230(), expected_function_231(), expected_function_232(), expected_function_233(), expected_function_234(), expected_function_235(), expected_function_236(), expected_function_237(), expected_function_238(), expected_function_239(), expected_function_240(), expected_function_241(), expected_function_242(), expected_function_243(), expected_function_244(), expected_function_245(), expected_function_246(), expected_function_247(), expected_function_248(), expected_function_249(), expected_function_250(), expected_function_251(), expected_function_252(), expected_function_253(), expected_function_254(), expected_function_255(), expected_function_256(), expected_function_257(), expected_function_258(), expected_function_259(), expected_function_260(), expected_function_261(), expected_function_262(), expected_function_263(), expected_function_264(), expected_function_265(), expected_function_266(), expected_function_267(), expected_function_268(), expected_function_269(), expected_function_270(), expected_function_271(), expected_function_272(), expected_function_273(), expected_function_274(), expected_function_275(), expected_function_276(), expected_function_277(), expected_function_278(), expected_function_279(), expected_function_280(), expected_function_281(), expected_function_282(), expected_function_283(), expected_function_284(), expected_function_285(), expected_function_286(), expected_function_287(), expected_function_288(), expected_function_289(), expected_function_290(), expected_function_291(), expected_function_292(), expected_function_293(), expected_function_294(), expected_function_295(), expected_function_296(), expected_function_297(), expected_function_298(), expected_function_299(), expected_function_300(), expected_function_301(), expected_function_302(), expected_function_303(), expected_function_304(), expected_function_305(), expected_function_306(), expected_function_307(), expected_function_308(), expected_function_309(), expected_function_310(), expected_function_311(), expected_function_312(), expected_function_313(), expected_function_314(), expected_function_315(), expected_function_316(), expected_function_317(), expected_function_318(), expected_function_319(), expected_function_320(), expected_function_321(), expected_function_322(), expected_function_323(), expected_function_324(), expected_function_325(), expected_function_326(), expected_function_327(), expected_function_328(), expected_function_329(), expected_function_330(), expected_function_331(), expected_function_332(), expected_function_333(), expected_function_334(), expected_function_335(), expected_function_336(), expected_function_337(), expected_function_338(), expected_function_339(), expected_function_340(), expected_function_341(), expected_function_342(), expected_function_343(), expected_function_344(), expected_function_345(), expected_function_346(), expected_function_347(), expected_function_348(), expected_function_349(), expected_function_350(), expected_function_351(), expected_function_352(), expected_function_353(), expected_function_354(), expected_function_355(), expected_function_356(), expected_function_357(), expected_function_358(), expected_function_359(), expected_function_360(), expected_function_361(), expected_function_362(), expected_function_363(), expected_function_364(), expected_function_365(), expected_function_366(), expected_function_367(), expected_function_368(), expected_function_369(), expected_function_370(), expected_function_371(), expected_function_372(), expected_function_373(), expected_function_374(), expected_function_375(), expected_function_376(), expected_function_377(), expected_function_378(), expected_function_379(), expected_function_380(), expected_function_381(), expected_function_382(), expected_function_383(), expected_function_384(), expected_function_385(), expected_function_386(), expected_function_387(), expected_function_388(), expected_function_389(), expected_function_390(), expected_function_391(), expected_function_392(), expected_function_393(), expected_function_394(), expected_function_395(), expected_function_396(), expected_function_397(), expected_function_398(), expected_function_399(), expected_function_400(), expected_function_401(), expected_function_402(), expected_function_403(), expected_function_404(), expected_function_405(), expected_function_406(), expected_function_407(), expected_function_408(), expected_function_409(), expected_function_410(), expected_function_411(), expected_function_412(), expected_function_413(), expected_function_414(), expected_function_415(), expected_function_416(), expected_function_417(), expected_function_418(), expected_function_419(), expected_function_420(), expected_function_421(), expected_function_422(), expected_function_423(), expected_function_424(), expected_function_425(), expected_function_426(), expected_function_427(), expected_function_428(), expected_function_429(), expected_function_430(), expected_function_431(), expected_function_432(), expected_function_433(), expected_function_434(), expected_function_435(), expected_function_436(), expected_function_437(), expected_function_438(), expected_function_439(), expected_function_440(), expected_function_441(), expected_function_442(), expected_function_443(), expected_function_444(), expected_function_445(), expected_function_446(), expected_function_447(), expected_function_448(), expected_function_449(), expected_function_450(), expected_function_451(), expected_function_452(), expected_function_453(), expected_function_454(), expected_function_455(), expected_function_456(), expected_function_457(), expected_function_458(), expected_function_459(), expected_function_460(), expected_function_461(), expected_function_462(), expected_function_463(), expected_function_464(), expected_function_465(), expected_function_466(), expected_function_467(), expected_function_468(), expected_function_469(), expected_function_470(), expected_function_471(), expected_function_472(), expected_function_473(), expected_function_474(), expected_function_475(), expected_function_476(), expected_function_477(), expected_function_478(), expected_function_479(), expected_function_480(), expected_function_481(), expected_function_482(), expected_function_483(), expected_function_484(), expected_function_485(), expected_function_486(), expected_function_487(), expected_function_488(), expected_function_489(), expected_function_490(), expected_function_491(), expected_function_492(), expected_function_493(), expected_function_494(), expected_function_495(), expected_function_496(), expected_function_497(), expected_function_498(), expected_function_499(), expected_function_500(), expected_function_501(), expected_function_502(), expected_function_503(), expected_function_504(), expected_function_505(), expected_function_506(), expected_function_507(), expected_function_508(), expected_function_509(), expected_function_510(), expected_function_511(), expected_function_512(), expected_function_513(), expected_function_514(), expected_function_515(), expected_function_516(), expected_function_517(), expected_function_518(), expected_function_519(), expected_function_520(), expected_function_521(), expected_function_522(), expected_function_523(), expected_function_524(), expected_function_525(), expected_function_526(), expected_function_527(), expected_function_528(), expected_function_529(), expected_function_530(), expected_function_531(), expected_function_532(), expected_function_533(), expected_function_534(), expected_function_535(), expected_function_536(), expected_function_537(), expected_function_538(), expected_function_539(), expected_function_540(), expected_function_541(), expected_function_542(), expected_function_543(), expected_function_544(), expected_function_545(), expected_function_546(), expected_function_547(), expected_function_548(), expected_function_549(), expected_function_550(), expected_function_551(), expected_function_552(), expected_function_553(), expected_function_554(), expected_function_555(), expected_function_556(), expected_function_557(), expected_function_558(), expected_function_559(), expected_function_560(), expected_function_561(), expected_function_562(), expected_function_563(), expected_function_564(), expected_function_565(), expected_function_566(), expected_function_567(), expected_function_568(), expected_function_569(), expected_function_570(), expected_function_571(), expected_function_572(), expected_function_573(), expected_function_574(), expected_function_575(), expected_function_576(), expected_function_577(), expected_function_578(), expected_function_579(), expected_function_580(), expected_function_581(), expected_function_582(), expected_function_583(), expected_function_584(), expected_function_585(), expected_function_586(), expected_function_587(), expected_function_588(), expected_function_589(), expected_function_590(), expected_function_591(), expected_function_592(), expected_function_593(), expected_function_594(), expected_function_595(), expected_function_596(), expected_function_597(), expected_function_598(), expected_function_599(), expected_function_600(), expected_function_601(), expected_function_602(), expected_function_603(), expected_function_604(), expected_function_605(), expected_function_606(), expected_function_607(), expected_function_608(), expected_function_609(), expected_function_610(), expected_function_611(), expected_function_612(), expected_function_613(), expected_function_614(), expected_function_615(), expected_function_616(), expected_function_617(), expected_function_618(), expected_function_619(), expected_function_620(), expected_function_621(), expected_function_622(), expected_function_623(), expected_function_624(), expected_function_625(), expected_function_626(), expected_function_627(), expected_function_628(), expected_function_629(), expected_function_630(), expected_function_631(), expected_function_632(), expected_function_633(), expected_function_634(), expected_function_635(), expected_function_636(), expected_function_637(), expected_function_638(), expected_function_639(), expected_function_640(), expected_function_641(), expected_function_642(), expected_function_643(), expected_function_644(), expected_function_645(), expected_function_646(), expected_function_647(), expected_function_648(), expected_function_649(), expected_function_650(), expected_function_651(), expected_function_652(), expected_function_653(), expected_function_654(), expected_function_655(), expected_function_656(), expected_function_657(), expected_function_658(), expected_function_659(), expected_function_660(), expected_function_661(), expected_function_662(), expected_function_663(), expected_function_664(), expected_function_665(), expected_function_666(), expected_function_667(), expected_function_668(), expected_function_669(), expected_function_670(), expected_function_671(), expected_function_672(), expected_function_673(), expected_function_674(), expected_function_675(), expected_function_676(), expected_function_677(), expected_function_678(), expected_function_679(), expected_function_680(), expected_function_681(), expected_function_682(), expected_function_683(), expected_function_684(), expected_function_685(), expected_function_686(), expected_function_687(), expected_function_688(), expected_function_689(), expected_function_690(), expected_function_691(), expected_function_692(), expected_function_693(), expected_function_694(), expected_function_695(), expected_function_696(), expected_function_697(), expected_function_698(), expected_function_699(), expected_function_700(), expected_function_701(), expected_function_702(), expected_function_703(), expected_function_704(), expected_function_705(), expected_function_706(), expected_function_707(), expected_function_708(), expected_function_709(), expected_function_710(), expected_function_711(), expected_function_712(), expected_function_713(), expected_function_714(), expected_function_715(), expected_function_716(), expected_function_717(), expected_function_718(), expected_function_719(), expected_function_720(), expected_function_721(), expected_function_722(), expected_function_723(), expected_function_724(), expected_function_725(), expected_function_726(), expected_function_727(), expected_function_728(), expected_function_729(), expected_function_730(), expected_function_731(), expected_function_732(), expected_function_733(), expected_function_734(), expected_function_735(), expected_function_736(), expected_function_737(), expected_function_738(), expected_function_739(), expected_function_740(), expected_function_741(), expected_function_742(), expected_function_743(), expected_function_744(), expected_function_745(), expected_function_746(), expected_function_747(), expected_function_748(), expected_function_749(), expected_function_750(), expected_function_751(), expected_function_752(), expected_function_753(), expected_function_754(), expected_function_755(), expected_function_756(), expected_function_757(), expected_function_758(), expected_function_759(), expected_function_760(), expected_function_761(), expected_function_762(), expected_function_763(), expected_function_764(), expected_function_765(), expected_function_766(), expected_function_767(), expected_function_768(), expected_function_769(), expected_function_770(), expected_function_771(), expected_function_772(), expected_function_773(), expected_function_774(), expected_function_775(), expected_function_776(), expected_function_777(), expected_function_778(), expected_function_779(), expected_function_780(), expected_function_781(), expected_function_782(), expected_function_783(), expected_function_784(), expected_function_785(), expected_function_786(), expected_function_787(), expected_function_788(), expected_function_789(), expected_function_790(), expected_function_791(), expected_function_792(), expected_function_793(), expected_function_794(), expected_function_795(), expected_function_796(), expected_function_797(), expected_function_798(), expected_function_799(), expected_function_800(), expected_function_801(), expected_function_802(), expected_function_803(), expected_function_804(), expected_function_805(), expected_function_806()], memory_sizes: vec![2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 18, 19, 32, 34, 36, 47, 50, 64], circuits: vec![Circuit { members: vec![0, 351, 353, 491], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 22, lookups: 7 } }, Circuit { members: vec![1, 107, 284, 285, 292, 295, 593, 632, 639, 648, 688], layout: FunctionLayout { input_size: 7, selectors: 40, auxiliaries: 72, lookups: 20 } }, Circuit { members: vec![2], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 66, lookups: 4 } }, Circuit { members: vec![3], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![5], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![6], layout: FunctionLayout { input_size: 8, selectors: 128, auxiliaries: 8, lookups: 1 } }, Circuit { members: vec![7], layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![15, 17, 110, 144, 191, 226, 282, 283, 390, 391, 392, 600], layout: FunctionLayout { input_size: 16, selectors: 31, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![16, 227, 533, 716], layout: FunctionLayout { input_size: 16, selectors: 25, auxiliaries: 22, lookups: 16 } }, Circuit { members: vec![18, 19], layout: FunctionLayout { input_size: 8, selectors: 10, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![23, 71, 93, 94, 275, 444, 622, 683, 692, 700, 707, 720], layout: FunctionLayout { input_size: 33, selectors: 35, auxiliaries: 38, lookups: 8 } }, Circuit { members: vec![24, 112, 117, 474, 592, 640, 641, 721], layout: FunctionLayout { input_size: 2, selectors: 26, auxiliaries: 51, lookups: 8 } }, Circuit { members: vec![25, 297, 298, 300, 302, 656, 777], layout: FunctionLayout { input_size: 34, selectors: 25, auxiliaries: 142, lookups: 17 } }, Circuit { members: vec![26, 30, 121], layout: FunctionLayout { input_size: 6, selectors: 17, auxiliaries: 143, lookups: 9 } }, Circuit { members: vec![27], layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![28], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![29], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![31], layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 } }, Circuit { members: vec![35], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![36, 299, 655, 732, 735, 756, 757, 766, 774, 792, 794], layout: FunctionLayout { input_size: 19, selectors: 42, auxiliaries: 110, lookups: 9 } }, Circuit { members: vec![37, 198, 233, 243, 274, 566, 568, 579, 583, 584, 589, 590, 653, 765, 782, 801], layout: FunctionLayout { input_size: 17, selectors: 38, auxiliaries: 8, lookups: 7 } }, Circuit { members: vec![38, 40, 70, 281, 341, 470, 494, 510, 620, 628, 785], layout: FunctionLayout { input_size: 17, selectors: 32, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![39, 55, 62, 72, 148, 149, 294, 569, 581, 649, 708, 733, 736, 737, 759, 805], layout: FunctionLayout { input_size: 46, selectors: 38, auxiliaries: 22, lookups: 9 } }, Circuit { members: vec![41, 63, 347, 555, 564, 574, 575, 582, 586, 651, 652, 659, 750, 754, 790], layout: FunctionLayout { input_size: 3, selectors: 40, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![42], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 } }, Circuit { members: vec![43], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![44], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![45, 153, 213, 554, 559, 729, 730, 734, 744, 745, 746, 747, 748, 761, 762, 763], layout: FunctionLayout { input_size: 8, selectors: 32, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![46, 47, 48, 49, 50, 51, 61, 67, 69, 238, 571, 587, 749, 768, 784, 804], layout: FunctionLayout { input_size: 35, selectors: 37, auxiliaries: 42, lookups: 11 } }, Circuit { members: vec![52, 135, 209, 264, 679, 680], layout: FunctionLayout { input_size: 26, selectors: 37, auxiliaries: 73, lookups: 40 } }, Circuit { members: vec![60, 53, 193, 194, 217, 220, 224, 232, 234, 547, 551, 760, 764, 769, 772, 776], layout: FunctionLayout { input_size: 4, selectors: 34, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![54, 56, 65, 66, 68, 73, 151, 152, 561, 643, 657, 752, 771, 781, 788, 793], layout: FunctionLayout { input_size: 12, selectors: 36, auxiliaries: 53, lookups: 6 } }, Circuit { members: vec![57, 106, 114, 591, 631, 660, 678, 690, 694, 710, 722, 783], layout: FunctionLayout { input_size: 13, selectors: 37, auxiliaries: 53, lookups: 10 } }, Circuit { members: vec![58, 59, 75, 133, 268, 301, 312, 422, 424, 471, 661, 664, 670, 677, 706], layout: FunctionLayout { input_size: 3, selectors: 38, auxiliaries: 16, lookups: 9 } }, Circuit { members: vec![64, 245, 544, 553, 570, 572, 751, 753, 767, 770, 773, 775], layout: FunctionLayout { input_size: 99, selectors: 40, auxiliaries: 80, lookups: 33 } }, Circuit { members: vec![74, 78, 286, 287, 289, 723, 728], layout: FunctionLayout { input_size: 50, selectors: 27, auxiliaries: 15, lookups: 8 } }, Circuit { members: vec![76, 77, 132, 514, 608, 618, 642, 663, 671, 687, 702, 712, 743, 802], layout: FunctionLayout { input_size: 6, selectors: 24, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![79, 137, 377, 484, 605], layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![80], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 } }, Circuit { members: vec![81], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 } }, Circuit { members: vec![82, 116, 333, 411, 413], layout: FunctionLayout { input_size: 2, selectors: 15, auxiliaries: 25, lookups: 9 } }, Circuit { members: vec![83], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 24, lookups: 6 } }, Circuit { members: vec![84], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 22, lookups: 6 } }, Circuit { members: vec![85], layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![86], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 } }, Circuit { members: vec![87], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![88], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 } }, Circuit { members: vec![89], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 5 } }, Circuit { members: vec![90, 91], layout: FunctionLayout { input_size: 9, selectors: 6, auxiliaries: 23, lookups: 7 } }, Circuit { members: vec![92], layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 35, lookups: 6 } }, Circuit { members: vec![95, 127, 463], layout: FunctionLayout { input_size: 3, selectors: 19, auxiliaries: 42, lookups: 11 } }, Circuit { members: vec![96], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 98, lookups: 34 } }, Circuit { members: vec![97], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![98, 337, 406, 429, 468, 486, 487], layout: FunctionLayout { input_size: 9, selectors: 29, auxiliaries: 24, lookups: 10 } }, Circuit { members: vec![99], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![103, 108, 293, 352, 481, 489, 594, 630, 675, 693, 704], layout: FunctionLayout { input_size: 12, selectors: 37, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![104, 267, 279, 461], layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 19, lookups: 8 } }, Circuit { members: vec![109, 111, 207, 210, 255, 346, 397, 403, 419, 476, 603], layout: FunctionLayout { input_size: 4, selectors: 33, auxiliaries: 52, lookups: 10 } }, Circuit { members: vec![113, 118, 290, 304, 727], layout: FunctionLayout { input_size: 9, selectors: 9, auxiliaries: 88, lookups: 6 } }, Circuit { members: vec![115, 141, 460, 472, 717], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![119, 725], layout: FunctionLayout { input_size: 2, selectors: 15, auxiliaries: 55, lookups: 6 } }, Circuit { members: vec![122], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![123, 269, 277, 288, 323, 327, 541, 682, 691], layout: FunctionLayout { input_size: 6, selectors: 39, auxiliaries: 29, lookups: 10 } }, Circuit { members: vec![124], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 41, lookups: 7 } }, Circuit { members: vec![125], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![126, 273, 324, 538, 623, 633, 638, 674, 681, 686, 711], layout: FunctionLayout { input_size: 18, selectors: 37, auxiliaries: 24, lookups: 16 } }, Circuit { members: vec![128, 265, 330, 334, 360, 407], layout: FunctionLayout { input_size: 2, selectors: 21, auxiliaries: 17, lookups: 10 } }, Circuit { members: vec![129], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 9 } }, Circuit { members: vec![130], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 } }, Circuit { members: vec![131, 276, 338, 374, 646, 665, 668, 673, 696, 699, 713, 714, 779], layout: FunctionLayout { input_size: 4, selectors: 29, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![138], layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![139], layout: FunctionLayout { input_size: 17, selectors: 4, auxiliaries: 47, lookups: 7 } }, Circuit { members: vec![140], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![142, 146, 270, 609, 629, 697, 709], layout: FunctionLayout { input_size: 10, selectors: 21, auxiliaries: 21, lookups: 17 } }, Circuit { members: vec![143, 145, 154, 206, 400, 416, 418, 420, 536, 636, 637], layout: FunctionLayout { input_size: 6, selectors: 30, auxiliaries: 19, lookups: 6 } }, Circuit { members: vec![147, 150, 196, 230, 262, 401, 409, 545, 573], layout: FunctionLayout { input_size: 16, selectors: 37, auxiliaries: 31, lookups: 22 } }, Circuit { members: vec![155, 156, 157, 171, 179, 181, 187, 188, 189, 214, 215, 216, 221, 222, 223, 225], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![158, 159, 184, 185, 200, 201, 204, 388, 522, 523, 524, 526, 527, 528, 529, 601], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![160, 162, 163, 164, 165, 166, 167, 168, 169, 199, 202, 203, 387, 530, 531, 532], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![161, 170, 172, 173, 174, 175, 176, 177, 178, 180, 182, 183, 389, 519, 520, 521], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![186, 190, 253, 303, 306, 315, 513, 598, 611, 619, 676, 705], layout: FunctionLayout { input_size: 4, selectors: 40, auxiliaries: 10, lookups: 5 } }, Circuit { members: vec![192, 317, 350, 368, 597], layout: FunctionLayout { input_size: 4, selectors: 18, auxiliaries: 16, lookups: 11 } }, Circuit { members: vec![195, 228, 236, 311, 314], layout: FunctionLayout { input_size: 3, selectors: 37, auxiliaries: 41, lookups: 28 } }, Circuit { members: vec![197, 212, 237, 244, 258, 259, 313, 325, 546, 567, 738], layout: FunctionLayout { input_size: 4, selectors: 39, auxiliaries: 18, lookups: 12 } }, Circuit { members: vec![205, 252, 322, 394, 477, 612], layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 11, lookups: 7 } }, Circuit { members: vec![208, 229, 242, 260, 402, 543, 562, 578, 585], layout: FunctionLayout { input_size: 16, selectors: 40, auxiliaries: 33, lookups: 17 } }, Circuit { members: vec![211, 272, 307, 316, 537, 539], layout: FunctionLayout { input_size: 4, selectors: 31, auxiliaries: 20, lookups: 16 } }, Circuit { members: vec![218, 219, 525, 548, 549, 550, 552], layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![231, 251, 309, 318, 606, 615, 617, 669, 803], layout: FunctionLayout { input_size: 4, selectors: 30, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![235, 250, 261, 310, 412, 624], layout: FunctionLayout { input_size: 10, selectors: 27, auxiliaries: 35, lookups: 25 } }, Circuit { members: vec![239, 339, 359], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![241, 558, 563, 650, 731], layout: FunctionLayout { input_size: 2, selectors: 40, auxiliaries: 13, lookups: 8 } }, Circuit { members: vec![248, 296, 658, 689, 755, 758, 791], layout: FunctionLayout { input_size: 10, selectors: 40, auxiliaries: 109, lookups: 51 } }, Circuit { members: vec![254, 348, 534, 535, 604, 625, 635, 662, 695], layout: FunctionLayout { input_size: 7, selectors: 38, auxiliaries: 20, lookups: 10 } }, Circuit { members: vec![256, 319, 356, 369, 417, 421, 423, 602, 634], layout: FunctionLayout { input_size: 5, selectors: 38, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![257, 556, 557, 560, 577, 588, 644, 645, 666, 796], layout: FunctionLayout { input_size: 6, selectors: 40, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![263], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![266, 408, 482, 492, 540, 542, 684, 685, 698, 701], layout: FunctionLayout { input_size: 13, selectors: 37, auxiliaries: 50, lookups: 26 } }, Circuit { members: vec![278, 329, 340, 365, 410, 459, 610, 613], layout: FunctionLayout { input_size: 5, selectors: 26, auxiliaries: 13, lookups: 7 } }, Circuit { members: vec![280], layout: FunctionLayout { input_size: 5, selectors: 12, auxiliaries: 25, lookups: 7 } }, Circuit { members: vec![305, 320, 342, 395, 475], layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![308, 321, 396, 415, 516], layout: FunctionLayout { input_size: 9, selectors: 36, auxiliaries: 43, lookups: 24 } }, Circuit { members: vec![326, 328, 331, 414, 442, 445, 485, 511, 515, 715, 799], layout: FunctionLayout { input_size: 7, selectors: 34, auxiliaries: 12, lookups: 6 } }, Circuit { members: vec![332, 378, 382, 479, 626, 627, 703], layout: FunctionLayout { input_size: 5, selectors: 35, auxiliaries: 13, lookups: 6 } }, Circuit { members: vec![335, 443, 465, 512], layout: FunctionLayout { input_size: 3, selectors: 21, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![336, 457, 464], layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![343, 458, 473], layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![344], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![345], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![349], layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![354], layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 17, lookups: 14 } }, Circuit { members: vec![355, 478, 596], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![358, 490], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 18, lookups: 10 } }, Circuit { members: vec![361, 405], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 18, lookups: 13 } }, Circuit { members: vec![362], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![363], layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![364], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![366], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![367], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![370], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![371], layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 12, lookups: 9 } }, Circuit { members: vec![372], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 11, lookups: 4 } }, Circuit { members: vec![373, 449], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![375], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 6, lookups: 5 } }, Circuit { members: vec![376], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![379], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![380], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 } }, Circuit { members: vec![381], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![383], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 12, lookups: 5 } }, Circuit { members: vec![384], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![385], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![386, 435], layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 28, lookups: 10 } }, Circuit { members: vec![393, 398], layout: FunctionLayout { input_size: 4, selectors: 33, auxiliaries: 61, lookups: 38 } }, Circuit { members: vec![399], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![404], layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 32, lookups: 10 } }, Circuit { members: vec![425], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![427], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![428], layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 14, lookups: 8 } }, Circuit { members: vec![430, 467], layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 19, lookups: 6 } }, Circuit { members: vec![431], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![433], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![434], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![436], layout: FunctionLayout { input_size: 5, selectors: 18, auxiliaries: 37, lookups: 13 } }, Circuit { members: vec![437], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![438, 439], layout: FunctionLayout { input_size: 12, selectors: 16, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![440, 469], layout: FunctionLayout { input_size: 3, selectors: 19, auxiliaries: 48, lookups: 15 } }, Circuit { members: vec![446], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 6 } }, Circuit { members: vec![447], layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 11 } }, Circuit { members: vec![448, 454], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 16, lookups: 8 } }, Circuit { members: vec![450], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 9 } }, Circuit { members: vec![451], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 10, lookups: 5 } }, Circuit { members: vec![452], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![453], layout: FunctionLayout { input_size: 1, selectors: 12, auxiliaries: 23, lookups: 9 } }, Circuit { members: vec![456], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![462, 483, 488, 607, 614, 621], layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![466], layout: FunctionLayout { input_size: 4, selectors: 25, auxiliaries: 16, lookups: 6 } }, Circuit { members: vec![480], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![493], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![495], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![496], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 9 } }, Circuit { members: vec![497], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 22, lookups: 8 } }, Circuit { members: vec![498], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 7 } }, Circuit { members: vec![500], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 } }, Circuit { members: vec![502], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 } }, Circuit { members: vec![503], layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 14, lookups: 8 } }, Circuit { members: vec![504], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![505], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 8, lookups: 3 } }, Circuit { members: vec![506], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 9, lookups: 7 } }, Circuit { members: vec![507], layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 3 } }, Circuit { members: vec![508], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 17, lookups: 11 } }, Circuit { members: vec![509], layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 21, lookups: 11 } }, Circuit { members: vec![517], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![518], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![565], layout: FunctionLayout { input_size: 9, selectors: 40, auxiliaries: 12, lookups: 7 } }, Circuit { members: vec![595], layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 19, lookups: 5 } }, Circuit { members: vec![599], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 20, lookups: 8 } }, Circuit { members: vec![718], layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 26, lookups: 7 } }, Circuit { members: vec![719], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![724], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![726], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 6, lookups: 5 } }, Circuit { members: vec![739], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 36, lookups: 5 } }, Circuit { members: vec![740], layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 2, lookups: 3 } }, Circuit { members: vec![741], layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 82, lookups: 7 } }, Circuit { members: vec![742], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 37, lookups: 6 } }, Circuit { members: vec![778], layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 2 } }, Circuit { members: vec![780], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![786], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![787], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![789], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![795], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![797], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![798], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![800], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![806], layout: FunctionLayout { input_size: 14, selectors: 57, auxiliaries: 31, lookups: 8 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [105, 148, 4, 31, 222, 124, 60, 173, 125, 34, 225, 72, 91, 85, 247, 185, 3, 166, 203, 236, 62, 61, 0, 53, 211, 122, 15, 138, 124, 182, 105, 169], complete: false, expected: expected_program, functions: &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, output_size: 9, seed_words: 17, schema: &SCHEMA_16, pack: |context, seed| { pack_16(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_16_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_16_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_16(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, output_size: 1, seed_words: 13, schema: &SCHEMA_27, pack: pack_27, pack_typed: pack_27_typed, pack_checked: pack_27_checked, write: write_27 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, output_size: 64, seed_words: 194, schema: &SCHEMA_28, pack: pack_28, pack_typed: pack_28_typed, pack_checked: pack_28_checked, write: write_28 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, output_size: 1, seed_words: 158, schema: &SCHEMA_31, pack: pack_31, pack_typed: pack_31_typed, pack_checked: pack_31_checked, write: |seed, offsets, row| { write_31(seed, offsets, row); Ok(()) } }), +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_35, pack: pack_35, pack_typed: pack_35_typed, pack_checked: pack_35_checked, write: |seed, offsets, row| { write_35(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 }, output_size: 1, seed_words: 5, schema: &SCHEMA_43, pack: pack_43, pack_typed: pack_43_typed, pack_checked: pack_43_checked, write: write_43 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, output_size: 2, seed_words: 5, schema: &SCHEMA_79, pack: pack_79, pack_typed: pack_79_typed, pack_checked: pack_79_checked, write: write_79 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, output_size: 9, seed_words: 15, schema: &SCHEMA_80, pack: pack_80, pack_typed: pack_80_typed, pack_checked: pack_80_checked, write: write_80 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 24, lookups: 6 }, output_size: 10, seed_words: 15, schema: &SCHEMA_83, pack: pack_83, pack_typed: pack_83_typed, pack_checked: pack_83_checked, write: write_83 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 }, output_size: 2, seed_words: 25, schema: &SCHEMA_85, pack: pack_85, pack_typed: pack_85_typed, pack_checked: pack_85_checked, write: write_85 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 }, output_size: 4, seed_words: 7, schema: &SCHEMA_88, pack: pack_88, pack_typed: pack_88_typed, pack_checked: pack_88_checked, write: |seed, offsets, row| { write_88(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 5 }, output_size: 6, seed_words: 9, schema: &SCHEMA_89, pack: pack_89, pack_typed: pack_89_typed, pack_checked: pack_89_checked, write: |seed, offsets, row| { write_89(seed, offsets, row); Ok(()) } }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 35, lookups: 6 }, output_size: 2, seed_words: 35, schema: &SCHEMA_92, pack: pack_92, pack_typed: pack_92_typed, pack_checked: pack_92_checked, write: write_92 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 }, output_size: 2, seed_words: 24, schema: &SCHEMA_97, pack: pack_97, pack_typed: pack_97_typed, pack_checked: pack_97_checked, write: write_97 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, output_size: 2, seed_words: 9, schema: &SCHEMA_122, pack: pack_122, pack_typed: pack_122_typed, pack_checked: pack_122_checked, write: |seed, offsets, row| { write_122(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 41, lookups: 7 }, output_size: 1, seed_words: 44, schema: &SCHEMA_124, pack: pack_124, pack_typed: pack_124_typed, pack_checked: pack_124_checked, write: write_124 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 9 }, output_size: 2, seed_words: 16, schema: &SCHEMA_129, pack: pack_129, pack_typed: pack_129_typed, pack_checked: pack_129_checked, write: write_129 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, output_size: 1, seed_words: 5, schema: &SCHEMA_137, pack: pack_137, pack_typed: pack_137_typed, pack_checked: pack_137_checked, write: |seed, offsets, row| { write_137(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 17, selectors: 4, auxiliaries: 47, lookups: 7 }, output_size: 1, seed_words: 63, schema: &SCHEMA_139, pack: pack_139, pack_typed: pack_139_typed, pack_checked: pack_139_checked, write: write_139 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 8, auxiliaries: 22, lookups: 15 }, output_size: 1, seed_words: 16, schema: &SCHEMA_227, pack: pack_227, pack_typed: pack_227_typed, pack_checked: pack_227_checked, write: |seed, offsets, row| { write_227(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_263, pack: pack_263, pack_typed: pack_263_typed, pack_checked: pack_263_checked, write: write_263 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 6 }, output_size: 1, seed_words: 10, schema: &SCHEMA_349, pack: pack_349, pack_typed: pack_349_typed, pack_checked: pack_349_checked, write: write_349 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 17, lookups: 14 }, output_size: 1, seed_words: 10, schema: &SCHEMA_354, pack: pack_354, pack_typed: pack_354_typed, pack_checked: pack_354_checked, write: write_354 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 }, output_size: 1, seed_words: 6, schema: &SCHEMA_362, pack: pack_362, pack_typed: pack_362_typed, pack_checked: pack_362_checked, write: |seed, offsets, row| { write_362(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 9, lookups: 5 }, output_size: 1, seed_words: 10, schema: &SCHEMA_363, pack: pack_363, pack_typed: pack_363_typed, pack_checked: pack_363_checked, write: write_363 }), +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 }, output_size: 1, seed_words: 7, schema: &SCHEMA_370, pack: pack_370, pack_typed: pack_370_typed, pack_checked: pack_370_checked, write: write_370 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 12, lookups: 9 }, output_size: 1, seed_words: 12, schema: &SCHEMA_371, pack: pack_371, pack_typed: pack_371_typed, pack_checked: pack_371_checked, write: write_371 }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 3 }, output_size: 1, seed_words: 6, schema: &SCHEMA_377, pack: pack_377, pack_typed: pack_377_typed, pack_checked: pack_377_checked, write: write_377 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 }, output_size: 1, seed_words: 9, schema: &SCHEMA_379, pack: pack_379, pack_typed: pack_379_typed, pack_checked: pack_379_checked, write: write_379 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 }, output_size: 1, seed_words: 8, schema: &SCHEMA_380, pack: pack_380, pack_typed: pack_380_typed, pack_checked: pack_380_checked, write: write_380 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_381, pack: pack_381, pack_typed: pack_381_typed, pack_checked: pack_381_checked, write: write_381 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 52, lookups: 37 }, output_size: 2, seed_words: 47, schema: &SCHEMA_393, pack: pack_393, pack_typed: pack_393_typed, pack_checked: pack_393_checked, write: |seed, offsets, row| { write_393(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 24, auxiliaries: 61, lookups: 38 }, output_size: 1, seed_words: 39, schema: &SCHEMA_398, pack: pack_398, pack_typed: pack_398_typed, pack_checked: pack_398_checked, write: |seed, offsets, row| { write_398(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 9, lookups: 8 }, output_size: 1, seed_words: 5, schema: &SCHEMA_448, pack: pack_448, pack_typed: pack_448_typed, pack_checked: pack_448_checked, write: |seed, offsets, row| { write_448(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 16, lookups: 7 }, output_size: 2, seed_words: 14, schema: &SCHEMA_454, pack: pack_454, pack_typed: pack_454_typed, pack_checked: pack_454_checked, write: |seed, offsets, row| { write_454(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, output_size: 3, seed_words: 11, schema: &SCHEMA_484, pack: pack_484, pack_typed: pack_484_typed, pack_checked: pack_484_checked, write: |seed, offsets, row| { write_484(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 21, lookups: 11 }, output_size: 1, seed_words: 22, schema: &SCHEMA_509, pack: pack_509, pack_typed: pack_509_typed, pack_checked: pack_509_checked, write: write_509 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 19, lookups: 13 }, output_size: 1, seed_words: 14, schema: &SCHEMA_533, pack: pack_533, pack_typed: pack_533_typed, pack_checked: pack_533_checked, write: |seed, offsets, row| { write_533(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, output_size: 1, seed_words: 8, schema: &SCHEMA_605, pack: pack_605, pack_typed: pack_605_typed, pack_checked: pack_605_checked, write: write_605 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 13, selectors: 9, auxiliaries: 20, lookups: 15 }, output_size: 0, seed_words: 33, schema: &SCHEMA_716, pack: pack_716, pack_typed: pack_716_typed, pack_checked: pack_716_checked, write: write_716 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_724, pack: pack_724, pack_typed: pack_724_typed, pack_checked: pack_724_checked, write: write_724 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 6, lookups: 5 }, output_size: 0, seed_words: 8, schema: &SCHEMA_726, pack: pack_726, pack_typed: pack_726_typed, pack_checked: pack_726_checked, write: write_726 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_780, pack: pack_780, pack_typed: pack_780_typed, pack_checked: pack_780_checked, write: write_780 }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_786, pack: pack_786, pack_typed: pack_786_typed, pack_checked: pack_786_checked, write: write_786 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_789, pack: pack_789, pack_typed: pack_789_typed, pack_checked: pack_789_checked, write: write_789 }), +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_798, pack: pack_798, pack_typed: pack_798_typed, pack_checked: pack_798_checked, write: write_798 }), +None, +None, +None, +None, +None, +None, +None, +None +] }; diff --git a/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs b/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs new file mode 100644 index 000000000..e21b4685d --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs @@ -0,0 +1,861 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_ixvm_contract() -> *const u8; + fn aiur_trace_ixvm_schema() -> *const u8; + pub(super) fn aiur_trace_ixvm_16(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_27(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_28(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_31(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_35(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_43(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_79(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_80(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_83(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_85(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_88(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_89(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_92(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_97(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_122(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_124(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_129(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_137(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_139(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_227(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_263(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_349(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_354(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_362(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_363(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_370(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_371(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_377(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_379(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_380(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_381(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_393(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_398(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_448(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_454(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_484(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_509(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_533(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_605(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_716(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_724(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_726(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_780(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_786(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_789(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_798(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([105, 148, 4, 31, 222, 124, 60, 173, 125, 34, 225, 72, 91, 85, 247, 185, 3, 166, 203, 236, 62, 61, 0, 53, 211, 122, 15, 138, 124, 182, 105, 169], aiur_trace_ixvm_contract, aiur_trace_ixvm_schema, &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_16), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_27), +Some(aiur_trace_ixvm_28), +None, +None, +Some(aiur_trace_ixvm_31), +None, +None, +None, +Some(aiur_trace_ixvm_35), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_43), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_79), +Some(aiur_trace_ixvm_80), +None, +None, +Some(aiur_trace_ixvm_83), +None, +Some(aiur_trace_ixvm_85), +None, +None, +Some(aiur_trace_ixvm_88), +Some(aiur_trace_ixvm_89), +None, +None, +Some(aiur_trace_ixvm_92), +None, +None, +None, +None, +Some(aiur_trace_ixvm_97), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_122), +None, +Some(aiur_trace_ixvm_124), +None, +None, +None, +None, +Some(aiur_trace_ixvm_129), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_137), +None, +Some(aiur_trace_ixvm_139), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_227), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_263), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_349), +None, +None, +None, +None, +Some(aiur_trace_ixvm_354), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_362), +Some(aiur_trace_ixvm_363), +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_370), +Some(aiur_trace_ixvm_371), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_377), +None, +Some(aiur_trace_ixvm_379), +Some(aiur_trace_ixvm_380), +Some(aiur_trace_ixvm_381), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_393), +None, +None, +None, +None, +Some(aiur_trace_ixvm_398), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_448), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_454), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_484), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_509), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_533), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_605), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_716), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_724), +None, +Some(aiur_trace_ixvm_726), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_780), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_786), +None, +None, +Some(aiur_trace_ixvm_789), +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_798), +None, +None, +None, +None, +None, +None, +None, +None +], &[3, 67, 68, 3, 0, 6, 9, 9, 0, 0, 0, 0, 0, 0, 0, 17, 17, 9, 9, 9, 0, 0, 0, 71, 40, 170, 137, 13, 194, 5, 146, 158, 0, 0, 0, 162, 79, 13, 13, 14, 14, 15, 3, 5, 7, 10, 53, 53, 53, 58, 59, 59, 67, 3, 35, 28, 32, 26, 17, 8, 4, 55, 31, 16, 81, 33, 33, 60, 41, 62, 13, 22, 49, 52, 48, 13, 13, 13, 63, 5, 15, 15, 15, 15, 31, 25, 3, 7, 7, 9, 31, 31, 35, 21, 37, 34, 99, 24, 33, 24, 0, 0, 0, 2, 19, 0, 33, 62, 2, 15, 2, 16, 42, 57, 44, 13, 22, 49, 68, 48, 0, 91, 9, 23, 44, 4, 17, 45, 4, 16, 26, 6, 14, 5, 0, 17, 0, 5, 19, 63, 5, 13, 16, 5, 5, 6, 14, 17, 17, 17, 33, 33, 33, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 12, 4, 4, 19, 13, 11, 7, 2, 2, 2, 2, 2, 2, 8, 5, 15, 12, 32, 13, 13, 18, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 16, 31, 15, 14, 7, 3, 9, 2, 15, 19, 16, 32, 9, 0, 9, 22, 8, 18, 22, 0, 0, 11, 0, 22, 9, 12, 3, 18, 12, 8, 9, 12, 15, 20, 20, 27, 8, 34, 17, 18, 18, 12, 24, 18, 0, 14, 19, 11, 22, 7, 28, 14, 18, 30, 21, 17, 17, 39, 73, 39, 46, 22, 58, 89, 0, 37, 3, 17, 67, 119, 110, 145, 110, 95, 3, 60, 4, 55, 7, 11, 10, 10, 10, 9, 11, 14, 8, 15, 8, 14, 17, 12, 14, 9, 24, 12, 20, 13, 9, 14, 10, 12, 11, 7, 10, 7, 8, 13, 11, 8, 9, 7, 8, 12, 8, 9, 9, 7, 11, 25, 10, 6, 10, 10, 3, 2, 3, 10, 7, 9, 0, 6, 7, 6, 8, 6, 10, 7, 10, 7, 11, 5, 10, 7, 12, 9, 6, 8, 8, 11, 6, 10, 9, 8, 11, 10, 15, 12, 12, 31, 2, 2, 2, 2, 2, 2, 47, 9, 9, 18, 17, 39, 9, 10, 11, 11, 14, 31, 13, 12, 14, 25, 34, 10, 26, 35, 23, 11, 48, 14, 9, 17, 53, 23, 8, 9, 10, 8, 11, 0, 11, 16, 29, 23, 11, 0, 12, 12, 31, 34, 5, 13, 13, 46, 0, 13, 13, 13, 11, 9, 15, 5, 6, 20, 12, 8, 24, 14, 0, 11, 7, 9, 11, 15, 16, 10, 22, 8, 14, 18, 14, 14, 43, 12, 14, 13, 9, 34, 8, 17, 11, 5, 15, 14, 13, 40, 11, 11, 14, 27, 27, 12, 13, 20, 23, 39, 9, 18, 6, 12, 24, 10, 0, 10, 0, 10, 16, 13, 8, 13, 11, 21, 22, 6, 13, 11, 7, 9, 15, 43, 9, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 14, 8, 19, 8, 16, 22, 15, 17, 18, 31, 18, 32, 23, 3, 3, 1, 1, 1, 5, 2, 82, 10, 9, 10, 12, 12, 6, 9, 26, 32, 12, 14, 21, 15, 20, 13, 31, 62, 40, 48, 23, 17, 15, 0, 13, 16, 9, 0, 10, 10, 7, 9, 36, 10, 39, 11, 7, 7, 52, 51, 62, 13, 20, 4, 6, 6, 23, 2, 2, 9, 15, 8, 8, 10, 12, 18, 20, 15, 5, 11, 11, 10, 8, 0, 8, 17, 10, 8, 11, 12, 22, 36, 25, 10, 9, 11, 26, 13, 63, 72, 20, 11, 16, 8, 11, 32, 53, 50, 51, 17, 25, 16, 10, 7, 0, 71, 13, 14, 11, 11, 15, 0, 81, 120, 54, 89, 13, 16, 13, 7, 14, 15, 8, 10, 0, 7, 8, 16, 10, 0, 7, 19, 5, 8, 8, 28, 53, 57, 31, 24, 32, 36, 42, 26, 13, 55, 88, 23, 23, 33, 7, 32, 9, 8, 21, 36, 6, 10, 32, 10, 8, 8, 6, 18, 16, 13, 21, 28, 34, 15, 6, 9, 13, 33, 15, 25, 8, 16, 41, 54, 54, 7, 51, 8, 52, 63, 6, 8, 12, 85, 23, 9, 66, 21, 17, 18, 37, 34, 83, 40, 6, 12, 5, 5, 5, 5, 40, 14, 57, 52, 71, 14, 75, 66, 85, 75, 23, 2, 6, 6, 6, 4, 18, 68, 69, 49, 4, 84, 53, 4, 100, 112, 104, 5, 123, 9, 8, 8, 28, 9, 21, 22, 4, 8, 6, 54, 7, 13, 111, 65, 29, 89, 5, 14, 8, 7, 8, 7, 15, 9, 8, 33, 22, 42], &[16, 528, 536, 16, 0, 48, 72, 72, 0, 0, 0, 0, 0, 0, 0, 136, 24, 72, 72, 72, 0, 0, 0, 544, 296, 432, 840, 80, 848, 40, 416, 272, 0, 0, 0, 176, 416, 104, 88, 96, 96, 96, 16, 16, 32, 32, 416, 416, 416, 264, 272, 272, 408, 16, 272, 216, 216, 120, 96, 48, 24, 264, 168, 104, 504, 176, 176, 360, 280, 376, 88, 152, 304, 312, 304, 96, 96, 96, 392, 32, 112, 88, 88, 88, 232, 184, 16, 32, 24, 32, 232, 232, 264, 120, 288, 256, 440, 176, 240, 168, 0, 0, 0, 16, 120, 0, 240, 456, 16, 104, 16, 104, 312, 440, 320, 96, 160, 368, 512, 376, 0, 664, 56, 48, 80, 24, 24, 168, 24, 48, 176, 32, 96, 24, 0, 136, 0, 32, 120, 208, 40, 96, 64, 24, 24, 32, 64, 24, 24, 24, 64, 64, 64, 40, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 40, 24, 24, 72, 64, 48, 48, 16, 16, 16, 16, 16, 16, 32, 32, 72, 56, 152, 72, 64, 88, 40, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 48, 160, 72, 80, 32, 24, 48, 16, 88, 88, 80, 184, 56, 0, 32, 96, 40, 88, 160, 0, 0, 40, 0, 64, 48, 56, 24, 80, 56, 48, 40, 56, 64, 80, 80, 120, 48, 144, 96, 80, 96, 64, 128, 96, 0, 72, 88, 64, 168, 48, 200, 80, 112, 176, 144, 128, 128, 304, 576, 280, 336, 144, 416, 648, 0, 280, 24, 112, 416, 824, 760, 1032, 768, 712, 24, 384, 24, 384, 24, 72, 48, 40, 48, 48, 56, 80, 40, 64, 56, 64, 80, 64, 80, 48, 120, 72, 88, 48, 48, 56, 48, 40, 48, 40, 56, 32, 48, 80, 72, 48, 40, 48, 56, 80, 48, 56, 48, 48, 64, 160, 56, 32, 64, 56, 16, 16, 16, 40, 32, 32, 0, 32, 40, 32, 40, 32, 56, 40, 48, 40, 64, 32, 64, 40, 72, 40, 32, 32, 40, 56, 32, 56, 48, 48, 56, 56, 88, 72, 64, 200, 16, 16, 16, 16, 16, 16, 240, 48, 48, 88, 88, 104, 56, 56, 64, 64, 72, 176, 80, 72, 64, 136, 184, 64, 152, 200, 136, 72, 280, 88, 64, 104, 384, 144, 56, 40, 32, 32, 64, 0, 64, 96, 192, 136, 64, 0, 64, 72, 200, 192, 40, 104, 104, 304, 0, 80, 72, 88, 56, 40, 72, 24, 24, 96, 56, 40, 136, 48, 0, 56, 24, 32, 40, 64, 48, 40, 104, 32, 56, 96, 56, 40, 248, 72, 40, 64, 40, 216, 32, 80, 56, 24, 64, 64, 104, 256, 56, 56, 64, 160, 160, 56, 104, 104, 144, 224, 56, 128, 40, 64, 160, 56, 0, 72, 0, 64, 88, 88, 56, 80, 80, 120, 120, 32, 64, 72, 40, 40, 96, 248, 56, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 48, 32, 96, 48, 88, 112, 72, 88, 96, 160, 104, 152, 128, 16, 24, 8, 8, 8, 40, 16, 592, 80, 48, 48, 80, 80, 32, 48, 120, 136, 72, 56, 128, 88, 128, 104, 144, 408, 240, 280, 56, 120, 112, 0, 80, 96, 56, 0, 64, 56, 40, 48, 184, 56, 192, 56, 40, 32, 376, 368, 408, 104, 136, 24, 32, 32, 144, 16, 16, 56, 80, 24, 56, 56, 72, 112, 112, 72, 32, 72, 48, 56, 56, 0, 32, 104, 32, 32, 72, 72, 136, 184, 160, 56, 56, 72, 168, 96, 456, 504, 136, 64, 80, 32, 56, 200, 376, 376, 368, 104, 168, 104, 48, 48, 0, 496, 56, 80, 64, 64, 112, 0, 576, 848, 392, 608, 72, 80, 96, 48, 88, 88, 56, 64, 0, 48, 48, 96, 56, 0, 48, 120, 32, 56, 48, 200, 336, 328, 192, 160, 216, 208, 264, 168, 72, 400, 600, 144, 56, 224, 56, 208, 56, 56, 128, 224, 40, 64, 192, 56, 56, 64, 40, 96, 80, 56, 136, 176, 184, 104, 40, 56, 88, 184, 72, 160, 48, 112, 312, 376, 400, 40, 344, 32, 376, 440, 32, 40, 72, 624, 120, 56, 416, 104, 80, 88, 280, 272, 608, 296, 32, 96, 32, 40, 32, 32, 296, 104, 376, 368, 504, 104, 504, 464, 600, 504, 104, 16, 16, 16, 16, 32, 144, 536, 536, 360, 24, 624, 360, 24, 624, 696, 632, 24, 760, 72, 56, 48, 216, 56, 160, 120, 24, 48, 40, 424, 48, 96, 832, 488, 224, 696, 32, 96, 48, 48, 56, 40, 88, 64, 48, 184, 144, 312]) }; diff --git a/crates/aiur/src/trace_codegen/programs/mod.rs b/crates/aiur/src/trace_codegen/programs/mod.rs new file mode 100644 index 000000000..0e0664388 --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/mod.rs @@ -0,0 +1,183 @@ +//! Production kernels selected at code generation time. + +use std::sync::Arc; + +use super::{ + GeneratedProgram, contract, + cuda::{CudaLibrary, RegisteredCudaProgram}, +}; +use crate::bytecode::Toplevel; + +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ixvm; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ixvm_cuda; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod multi_stark; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod multi_stark_cuda; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ix_aggr; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ix_aggr_cuda; + +const PROGRAMS: &[(&str, &GeneratedProgram, &CudaLibrary)] = &[ + ("ixvm", &ixvm::PROGRAM, &ixvm_cuda::CUDA), + ("multi-stark", &multi_stark::PROGRAM, &multi_stark_cuda::CUDA), + ("ix-aggr", &ix_aggr::PROGRAM, &ix_aggr_cuda::CUDA), +]; + +pub(crate) fn register( + bytecode: Arc, +) -> Result { + let fingerprint = contract::fingerprint(&bytecode); + let Some(&(name, generated, cuda)) = PROGRAMS + .iter() + .find(|(_, generated, _)| generated.fingerprint == fingerprint) + else { + return Err("no generated CUDA library matches this bytecode; regenerate with ix codegen --trace-bundle and rebuild".into()); + }; + let registered = cuda + .register(generated, bytecode.clone()) + .map_err(|error| format!("{name}: {error}"))?; + let covered = (0..bytecode.circuits.len()) + .filter(|&c| registered.bound().supports(c)) + .count(); + tracing::info!( + program = name, + generated_functions = + generated.functions.iter().filter(|f| f.is_some()).count(), + constrained_functions = + bytecode.functions.iter().filter(|f| f.constrained).count(), + generated_circuits = covered, + function_circuits = bytecode.circuits.len(), + "registered generated CUDA traces; uncovered circuits use CPU traces" + ); + Ok(registered) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{ + G, + execute::{IOBuffer, QueryRecord}, + gpu_trace::TraceProvider, + }; + use ::multi_stark::{ + cuda::CudaDft, + p3_field::{PrimeCharacteristicRing, PrimeField64}, + witness::TraceSource, + }; + + #[test] + fn production_registration_and_dispatch_match_oracle() { + let fixture = (crate::trace_codegen::tests::blake3::PROGRAM.expected)(); + let mut io = IOBuffer { data: Default::default(), map: Default::default() }; + let mut input = vec![G::ZERO]; + input.extend((0..128).map(|i| G::from_usize((i * 37 + 19) % 256))); + let (fixture_record, _) = fixture.execute(0, input, &mut io).unwrap(); + for &(name, generated, _) in PROGRAMS { + assert!(!generated.complete); + let top = Arc::new((generated.expected)()); + let selected: Vec<_> = generated + .functions + .iter() + .enumerate() + .filter_map(|(i, f)| f.as_ref().map(|_| i)) + .collect(); + // The selection is whole circuits, so every member of a covered + // circuit is generated and no generated function is left uncovered. + let registered = register(top.clone()).unwrap(); + let covered: Vec<_> = (0..top.circuits.len()) + .filter(|&c| registered.bound().supports(c)) + .collect(); + let mut covered_functions: Vec<_> = + covered.iter().flat_map(|&c| top.circuits[c].members.clone()).collect(); + covered_functions.sort_unstable(); + assert_eq!(covered_functions, selected, "{name}: partial circuit"); + // BLAKE3 is the member whose rows the fixture record supplies. + let function = selected + .iter() + .copied() + .find(|&f| top.functions[f].layout == fixture.functions[0].layout) + .expect("blake3_compress is selected"); + let circuit = top + .circuits + .iter() + .position(|c| c.members.contains(&function)) + .unwrap(); + assert_eq!(top.circuits[circuit].members, [function]); + let provider = TraceProvider::Generated(registered); + let mut record = QueryRecord::new(&top); + for (input, result) in fixture_record.function_queries[0].iter() { + record.function_queries[function] + .insert(input, result.output, result.multiplicity) + .unwrap(); + } + let count = record.function_queries[function].len(); + let (source, _) = provider + .prepare( + &top, + circuit, + &record, + &io, + &[], + (0, 0), + (0, count), + count, + false, + ) + .unwrap(); + let mut expected: Vec<_> = (0..count) + .flat_map(|row| { + top.main_row_for_test(circuit, function, row, &record, &io) + }) + .map(|cell| cell.as_canonical_u64()) + .collect(); + let width = top.circuits[circuit].layout.width(); + let height = count.next_power_of_two(); + expected.resize(height * width, 0); + let TraceSource::Generated(source) = source else { + panic!("{name}: missing generated source") + }; + let rows = + CudaDft::new(0).generated_trace_rows(source, height - 1, height + 1); + let raw = unsafe { + std::slice::from_raw_parts( + rows.values.as_ptr().cast::(), + rows.values.len(), + ) + }; + for (i, &word) in raw.iter().enumerate() { + assert_eq!( + word, + expected[(((height - 1) + i / width) % height) * width + i % width], + "{name}: cell {i}" + ); + } + let uncovered = + (0..top.circuits.len()).find(|&c| !covered.contains(&c)).unwrap(); + assert!( + provider + .prepare(&top, uncovered, &record, &io, &[], (0, 0), (0, 1), 1, false) + .is_none() + ); + assert!( + provider + .prepare(&top, circuit, &record, &io, &[], (0, 0), (0, 0), 0, false) + .is_none() + ); + let mut stale = (generated.expected)(); + stale.functions[0].entry = !stale.functions[0].entry; + assert!(register(Arc::new(stale)).is_err()); + } + assert!(register(Arc::new(fixture)).is_err()); + } +} diff --git a/crates/aiur/src/trace_codegen/programs/multi_stark.rs b/crates/aiur/src/trace_codegen/programs/multi_stark.rs new file mode 100644 index 000000000..d1470e6b2 --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/multi_stark.rs @@ -0,0 +1,1647 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_76(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); seed[97] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed[131] = v_130.as_canonical_u64(); seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed[143] = v_142.as_canonical_u64(); seed[144] = v_143.as_canonical_u64(); seed[145] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed[146] = v_145.as_canonical_u64(); seed[147] = v_146.as_canonical_u64(); seed[148] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed[149] = v_148.as_canonical_u64(); seed[150] = v_149.as_canonical_u64(); seed[151] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed[152] = v_151.as_canonical_u64(); seed[153] = v_152.as_canonical_u64(); seed[154] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed[155] = v_154.as_canonical_u64(); seed[156] = v_155.as_canonical_u64(); seed[157] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed[158] = v_157.as_canonical_u64(); seed[159] = v_158.as_canonical_u64(); seed[160] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed[161] = v_160.as_canonical_u64(); seed[162] = v_161.as_canonical_u64(); seed[163] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed[164] = v_163.as_canonical_u64(); seed[165] = v_164.as_canonical_u64(); seed[166] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed[167] = v_166.as_canonical_u64(); seed[168] = v_167.as_canonical_u64(); seed[169] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed[170] = v_169.as_canonical_u64(); seed[171] = v_170.as_canonical_u64(); seed[172] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed[173] = v_172.as_canonical_u64(); seed[174] = v_173.as_canonical_u64(); seed[175] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed[176] = v_175.as_canonical_u64(); seed[177] = v_176.as_canonical_u64(); seed[178] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed[179] = v_178.as_canonical_u64(); seed[180] = v_179.as_canonical_u64(); seed[181] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed[182] = v_181.as_canonical_u64(); seed[183] = v_182.as_canonical_u64(); seed[184] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed[185] = v_184.as_canonical_u64(); seed[186] = v_185.as_canonical_u64(); seed[187] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed[188] = v_187.as_canonical_u64(); seed[189] = v_188.as_canonical_u64(); seed[190] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed[191] = v_190.as_canonical_u64(); seed[192] = v_191.as_canonical_u64(); seed[193] = v_192.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(76, v_187)) }, } }, _ => { Err(no_match(76, v_184)) }, } }, _ => { Err(no_match(76, v_181)) }, } }, _ => { Err(no_match(76, v_178)) }, } }, _ => { Err(no_match(76, v_175)) }, } }, _ => { Err(no_match(76, v_172)) }, } }, _ => { Err(no_match(76, v_169)) }, } }, _ => { Err(no_match(76, v_166)) }, } }, _ => { Err(no_match(76, v_163)) }, } }, _ => { Err(no_match(76, v_160)) }, } }, _ => { Err(no_match(76, v_157)) }, } }, _ => { Err(no_match(76, v_154)) }, } }, _ => { Err(no_match(76, v_151)) }, } }, _ => { Err(no_match(76, v_148)) }, } }, _ => { Err(no_match(76, v_145)) }, } }, _ => { Err(no_match(76, v_142)) }, } }, _ => { Err(no_match(76, v_139)) }, } }, _ => { Err(no_match(76, v_136)) }, } }, _ => { Err(no_match(76, v_133)) }, } }, _ => { Err(no_match(76, v_130)) }, } }, _ => { Err(no_match(76, v_127)) }, } }, _ => { Err(no_match(76, v_124)) }, } }, _ => { Err(no_match(76, v_121)) }, } }, _ => { Err(no_match(76, v_118)) }, } }, _ => { Err(no_match(76, v_115)) }, } }, _ => { Err(no_match(76, v_112)) }, } }, _ => { Err(no_match(76, v_109)) }, } }, _ => { Err(no_match(76, v_106)) }, } }, _ => { Err(no_match(76, v_103)) }, } }, _ => { Err(no_match(76, v_100)) }, } }, _ => { Err(no_match(76, v_97)) }, } }, _ => { Err(no_match(76, v_94)) }, } }, _ => { Err(no_match(76, v_91)) }, } }, _ => { Err(no_match(76, v_88)) }, } }, _ => { Err(no_match(76, v_85)) }, } }, _ => { Err(no_match(76, v_82)) }, } }, _ => { Err(no_match(76, v_79)) }, } }, _ => { Err(no_match(76, v_76)) }, } }, _ => { Err(no_match(76, v_73)) }, } }, _ => { Err(no_match(76, v_70)) }, } }, _ => { Err(no_match(76, v_67)) }, } }, _ => { Err(no_match(76, v_64)) }, } }, _ => { Err(no_match(76, v_61)) }, } }, _ => { Err(no_match(76, v_58)) }, } }, _ => { Err(no_match(76, v_55)) }, } }, _ => { Err(no_match(76, v_52)) }, } }, _ => { Err(no_match(76, v_49)) }, } }, _ => { Err(no_match(76, v_46)) }, } }, _ => { Err(no_match(76, v_43)) }, } }, _ => { Err(no_match(76, v_40)) }, } }, _ => { Err(no_match(76, v_37)) }, } }, _ => { Err(no_match(76, v_34)) }, } }, _ => { Err(no_match(76, v_31)) }, } }, _ => { Err(no_match(76, v_28)) }, } }, _ => { Err(no_match(76, v_25)) }, } }, _ => { Err(no_match(76, v_22)) }, } }, _ => { Err(no_match(76, v_19)) }, } }, _ => { Err(no_match(76, v_16)) }, } }, _ => { Err(no_match(76, v_13)) }, } }, _ => { Err(no_match(76, v_10)) }, } }, _ => { Err(no_match(76, v_7)) }, } }, _ => { Err(no_match(76, v_4)) }, } }, _ => { Err(no_match(76, v_1)) }, } } + +fn pack_76_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(784, v_1); seed.full(8, v_2); seed.u32(532, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed.u8(785, v_4); seed.full(16, v_5); seed.u32(536, v_6); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed.u8(786, v_7); seed.full(24, v_8); seed.u32(540, v_9); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed.u8(787, v_10); seed.full(32, v_11); seed.u32(544, v_12); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed.u8(788, v_13); seed.full(40, v_14); seed.u32(548, v_15); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed.u8(789, v_16); seed.full(48, v_17); seed.u32(552, v_18); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed.u8(790, v_19); seed.full(56, v_20); seed.u32(556, v_21); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed.u8(791, v_22); seed.full(64, v_23); seed.u32(560, v_24); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed.u8(792, v_25); seed.full(72, v_26); seed.u32(564, v_27); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed.u8(793, v_28); seed.full(80, v_29); seed.u32(568, v_30); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed.u8(794, v_31); seed.full(88, v_32); seed.u32(572, v_33); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed.u8(795, v_34); seed.full(96, v_35); seed.u32(576, v_36); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed.u8(796, v_37); seed.full(104, v_38); seed.u32(580, v_39); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed.u8(797, v_40); seed.full(112, v_41); seed.u32(584, v_42); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed.u8(798, v_43); seed.full(120, v_44); seed.u32(588, v_45); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed.u8(799, v_46); seed.full(128, v_47); seed.u32(592, v_48); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed.u8(800, v_49); seed.full(136, v_50); seed.u32(596, v_51); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed.u8(801, v_52); seed.full(144, v_53); seed.u32(600, v_54); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed.u8(802, v_55); seed.full(152, v_56); seed.u32(604, v_57); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed.u8(803, v_58); seed.full(160, v_59); seed.u32(608, v_60); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed.u8(804, v_61); seed.full(168, v_62); seed.u32(612, v_63); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed.u8(805, v_64); seed.full(176, v_65); seed.u32(616, v_66); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed.u8(806, v_67); seed.full(184, v_68); seed.u32(620, v_69); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed.u8(807, v_70); seed.full(192, v_71); seed.u32(624, v_72); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed.u8(808, v_73); seed.full(200, v_74); seed.u32(628, v_75); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed.u8(809, v_76); seed.full(208, v_77); seed.u32(632, v_78); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed.u8(810, v_79); seed.full(216, v_80); seed.u32(636, v_81); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed.u8(811, v_82); seed.full(224, v_83); seed.u32(640, v_84); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed.u8(812, v_85); seed.full(232, v_86); seed.u32(644, v_87); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed.u8(813, v_88); seed.full(240, v_89); seed.u32(648, v_90); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed.u8(814, v_91); seed.full(248, v_92); seed.u32(652, v_93); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed.u8(815, v_94); seed.full(256, v_95); seed.u32(656, v_96); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed.u8(816, v_97); seed.full(264, v_98); seed.u32(660, v_99); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed.u8(817, v_100); seed.full(272, v_101); seed.u32(664, v_102); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed.u8(818, v_103); seed.full(280, v_104); seed.u32(668, v_105); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed.u8(819, v_106); seed.full(288, v_107); seed.u32(672, v_108); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed.u8(820, v_109); seed.full(296, v_110); seed.u32(676, v_111); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed.u8(821, v_112); seed.full(304, v_113); seed.u32(680, v_114); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed.u8(822, v_115); seed.full(312, v_116); seed.u32(684, v_117); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed.u8(823, v_118); seed.full(320, v_119); seed.u32(688, v_120); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed.u8(824, v_121); seed.full(328, v_122); seed.u32(692, v_123); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed.u8(825, v_124); seed.full(336, v_125); seed.u32(696, v_126); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed.u8(826, v_127); seed.full(344, v_128); seed.u32(700, v_129); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed.u8(827, v_130); seed.full(352, v_131); seed.u32(704, v_132); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed.u8(828, v_133); seed.full(360, v_134); seed.u32(708, v_135); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed.u8(829, v_136); seed.full(368, v_137); seed.u32(712, v_138); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed.u8(830, v_139); seed.full(376, v_140); seed.u32(716, v_141); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed.u8(831, v_142); seed.full(384, v_143); seed.u32(720, v_144); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed.u8(832, v_145); seed.full(392, v_146); seed.u32(724, v_147); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed.u8(833, v_148); seed.full(400, v_149); seed.u32(728, v_150); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed.u8(834, v_151); seed.full(408, v_152); seed.u32(732, v_153); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed.u8(835, v_154); seed.full(416, v_155); seed.u32(736, v_156); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed.u8(836, v_157); seed.full(424, v_158); seed.u32(740, v_159); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed.u8(837, v_160); seed.full(432, v_161); seed.u32(744, v_162); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed.u8(838, v_163); seed.full(440, v_164); seed.u32(748, v_165); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed.u8(839, v_166); seed.full(448, v_167); seed.u32(752, v_168); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed.u8(840, v_169); seed.full(456, v_170); seed.u32(756, v_171); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed.u8(841, v_172); seed.full(464, v_173); seed.u32(760, v_174); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed.u8(842, v_175); seed.full(472, v_176); seed.u32(764, v_177); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed.u8(843, v_178); seed.full(480, v_179); seed.u32(768, v_180); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed.u8(844, v_181); seed.full(488, v_182); seed.u32(772, v_183); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed.u8(845, v_184); seed.full(496, v_185); seed.u32(776, v_186); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed.u8(846, v_187); seed.full(504, v_188); seed.u32(780, v_189); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed.u8(847, v_190); seed.full(512, v_191); seed.full(520, v_192); Ok(()) }, _ => { Err(no_match(76, v_187)) }, } }, _ => { Err(no_match(76, v_184)) }, } }, _ => { Err(no_match(76, v_181)) }, } }, _ => { Err(no_match(76, v_178)) }, } }, _ => { Err(no_match(76, v_175)) }, } }, _ => { Err(no_match(76, v_172)) }, } }, _ => { Err(no_match(76, v_169)) }, } }, _ => { Err(no_match(76, v_166)) }, } }, _ => { Err(no_match(76, v_163)) }, } }, _ => { Err(no_match(76, v_160)) }, } }, _ => { Err(no_match(76, v_157)) }, } }, _ => { Err(no_match(76, v_154)) }, } }, _ => { Err(no_match(76, v_151)) }, } }, _ => { Err(no_match(76, v_148)) }, } }, _ => { Err(no_match(76, v_145)) }, } }, _ => { Err(no_match(76, v_142)) }, } }, _ => { Err(no_match(76, v_139)) }, } }, _ => { Err(no_match(76, v_136)) }, } }, _ => { Err(no_match(76, v_133)) }, } }, _ => { Err(no_match(76, v_130)) }, } }, _ => { Err(no_match(76, v_127)) }, } }, _ => { Err(no_match(76, v_124)) }, } }, _ => { Err(no_match(76, v_121)) }, } }, _ => { Err(no_match(76, v_118)) }, } }, _ => { Err(no_match(76, v_115)) }, } }, _ => { Err(no_match(76, v_112)) }, } }, _ => { Err(no_match(76, v_109)) }, } }, _ => { Err(no_match(76, v_106)) }, } }, _ => { Err(no_match(76, v_103)) }, } }, _ => { Err(no_match(76, v_100)) }, } }, _ => { Err(no_match(76, v_97)) }, } }, _ => { Err(no_match(76, v_94)) }, } }, _ => { Err(no_match(76, v_91)) }, } }, _ => { Err(no_match(76, v_88)) }, } }, _ => { Err(no_match(76, v_85)) }, } }, _ => { Err(no_match(76, v_82)) }, } }, _ => { Err(no_match(76, v_79)) }, } }, _ => { Err(no_match(76, v_76)) }, } }, _ => { Err(no_match(76, v_73)) }, } }, _ => { Err(no_match(76, v_70)) }, } }, _ => { Err(no_match(76, v_67)) }, } }, _ => { Err(no_match(76, v_64)) }, } }, _ => { Err(no_match(76, v_61)) }, } }, _ => { Err(no_match(76, v_58)) }, } }, _ => { Err(no_match(76, v_55)) }, } }, _ => { Err(no_match(76, v_52)) }, } }, _ => { Err(no_match(76, v_49)) }, } }, _ => { Err(no_match(76, v_46)) }, } }, _ => { Err(no_match(76, v_43)) }, } }, _ => { Err(no_match(76, v_40)) }, } }, _ => { Err(no_match(76, v_37)) }, } }, _ => { Err(no_match(76, v_34)) }, } }, _ => { Err(no_match(76, v_31)) }, } }, _ => { Err(no_match(76, v_28)) }, } }, _ => { Err(no_match(76, v_25)) }, } }, _ => { Err(no_match(76, v_22)) }, } }, _ => { Err(no_match(76, v_19)) }, } }, _ => { Err(no_match(76, v_16)) }, } }, _ => { Err(no_match(76, v_13)) }, } }, _ => { Err(no_match(76, v_10)) }, } }, _ => { Err(no_match(76, v_7)) }, } }, _ => { Err(no_match(76, v_4)) }, } }, _ => { Err(no_match(76, v_1)) }, } } + +fn pack_76_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); seed[97] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed[131] = v_130.as_canonical_u64(); seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed[143] = v_142.as_canonical_u64(); seed[144] = v_143.as_canonical_u64(); seed[145] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed[146] = v_145.as_canonical_u64(); seed[147] = v_146.as_canonical_u64(); seed[148] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed[149] = v_148.as_canonical_u64(); seed[150] = v_149.as_canonical_u64(); seed[151] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed[152] = v_151.as_canonical_u64(); seed[153] = v_152.as_canonical_u64(); seed[154] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed[155] = v_154.as_canonical_u64(); seed[156] = v_155.as_canonical_u64(); seed[157] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed[158] = v_157.as_canonical_u64(); seed[159] = v_158.as_canonical_u64(); seed[160] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed[161] = v_160.as_canonical_u64(); seed[162] = v_161.as_canonical_u64(); seed[163] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed[164] = v_163.as_canonical_u64(); seed[165] = v_164.as_canonical_u64(); seed[166] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed[167] = v_166.as_canonical_u64(); seed[168] = v_167.as_canonical_u64(); seed[169] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed[170] = v_169.as_canonical_u64(); seed[171] = v_170.as_canonical_u64(); seed[172] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed[173] = v_172.as_canonical_u64(); seed[174] = v_173.as_canonical_u64(); seed[175] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed[176] = v_175.as_canonical_u64(); seed[177] = v_176.as_canonical_u64(); seed[178] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed[179] = v_178.as_canonical_u64(); seed[180] = v_179.as_canonical_u64(); seed[181] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed[182] = v_181.as_canonical_u64(); seed[183] = v_182.as_canonical_u64(); seed[184] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed[185] = v_184.as_canonical_u64(); seed[186] = v_185.as_canonical_u64(); seed[187] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed[188] = v_187.as_canonical_u64(); seed[189] = v_188.as_canonical_u64(); seed[190] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed[191] = v_190.as_canonical_u64(); seed[192] = v_191.as_canonical_u64(); seed[193] = v_192.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(76, v_187)) }, } }, _ => { Err(no_match(76, v_184)) }, } }, _ => { Err(no_match(76, v_181)) }, } }, _ => { Err(no_match(76, v_178)) }, } }, _ => { Err(no_match(76, v_175)) }, } }, _ => { Err(no_match(76, v_172)) }, } }, _ => { Err(no_match(76, v_169)) }, } }, _ => { Err(no_match(76, v_166)) }, } }, _ => { Err(no_match(76, v_163)) }, } }, _ => { Err(no_match(76, v_160)) }, } }, _ => { Err(no_match(76, v_157)) }, } }, _ => { Err(no_match(76, v_154)) }, } }, _ => { Err(no_match(76, v_151)) }, } }, _ => { Err(no_match(76, v_148)) }, } }, _ => { Err(no_match(76, v_145)) }, } }, _ => { Err(no_match(76, v_142)) }, } }, _ => { Err(no_match(76, v_139)) }, } }, _ => { Err(no_match(76, v_136)) }, } }, _ => { Err(no_match(76, v_133)) }, } }, _ => { Err(no_match(76, v_130)) }, } }, _ => { Err(no_match(76, v_127)) }, } }, _ => { Err(no_match(76, v_124)) }, } }, _ => { Err(no_match(76, v_121)) }, } }, _ => { Err(no_match(76, v_118)) }, } }, _ => { Err(no_match(76, v_115)) }, } }, _ => { Err(no_match(76, v_112)) }, } }, _ => { Err(no_match(76, v_109)) }, } }, _ => { Err(no_match(76, v_106)) }, } }, _ => { Err(no_match(76, v_103)) }, } }, _ => { Err(no_match(76, v_100)) }, } }, _ => { Err(no_match(76, v_97)) }, } }, _ => { Err(no_match(76, v_94)) }, } }, _ => { Err(no_match(76, v_91)) }, } }, _ => { Err(no_match(76, v_88)) }, } }, _ => { Err(no_match(76, v_85)) }, } }, _ => { Err(no_match(76, v_82)) }, } }, _ => { Err(no_match(76, v_79)) }, } }, _ => { Err(no_match(76, v_76)) }, } }, _ => { Err(no_match(76, v_73)) }, } }, _ => { Err(no_match(76, v_70)) }, } }, _ => { Err(no_match(76, v_67)) }, } }, _ => { Err(no_match(76, v_64)) }, } }, _ => { Err(no_match(76, v_61)) }, } }, _ => { Err(no_match(76, v_58)) }, } }, _ => { Err(no_match(76, v_55)) }, } }, _ => { Err(no_match(76, v_52)) }, } }, _ => { Err(no_match(76, v_49)) }, } }, _ => { Err(no_match(76, v_46)) }, } }, _ => { Err(no_match(76, v_43)) }, } }, _ => { Err(no_match(76, v_40)) }, } }, _ => { Err(no_match(76, v_37)) }, } }, _ => { Err(no_match(76, v_34)) }, } }, _ => { Err(no_match(76, v_31)) }, } }, _ => { Err(no_match(76, v_28)) }, } }, _ => { Err(no_match(76, v_25)) }, } }, _ => { Err(no_match(76, v_22)) }, } }, _ => { Err(no_match(76, v_19)) }, } }, _ => { Err(no_match(76, v_16)) }, } }, _ => { Err(no_match(76, v_13)) }, } }, _ => { Err(no_match(76, v_10)) }, } }, _ => { Err(no_match(76, v_7)) }, } }, _ => { Err(no_match(76, v_4)) }, } }, _ => { Err(no_match(76, v_1)) }, } } + +fn write_76(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31])]; row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = [G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = [G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40])]; row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = [G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = [G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = [G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = [G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 49] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = [G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55])]; row[offsets.auxiliaries + 52] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = [G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58])]; row[offsets.auxiliaries + 55] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = [G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 58] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 61] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = [G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67])]; row[offsets.auxiliaries + 64] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = [G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 67] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = [G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73])]; row[offsets.auxiliaries + 70] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = [G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76])]; row[offsets.auxiliaries + 73] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = [G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 76] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = [G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82])]; row[offsets.auxiliaries + 79] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = [G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85])]; row[offsets.auxiliaries + 82] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = [G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88])]; row[offsets.auxiliaries + 85] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = [G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91])]; row[offsets.auxiliaries + 88] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = [G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 91] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 94] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = [G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100])]; row[offsets.auxiliaries + 97] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = [G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103])]; row[offsets.auxiliaries + 100] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = [G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106])]; row[offsets.auxiliaries + 103] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = [G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109])]; row[offsets.auxiliaries + 106] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = [G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 109] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 112] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = [G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118])]; row[offsets.auxiliaries + 115] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = [G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121])]; row[offsets.auxiliaries + 118] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = [G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124])]; row[offsets.auxiliaries + 121] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = [G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127])]; row[offsets.auxiliaries + 124] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = [G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130])]; row[offsets.auxiliaries + 127] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = [G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133])]; row[offsets.auxiliaries + 130] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = [G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136])]; row[offsets.auxiliaries + 133] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = [G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139])]; row[offsets.auxiliaries + 136] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = [G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142])]; row[offsets.auxiliaries + 139] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = [G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 142] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = [G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 145] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151])]; row[offsets.auxiliaries + 148] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = [G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 151] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = [G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157])]; row[offsets.auxiliaries + 154] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = [G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160])]; row[offsets.auxiliaries + 157] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = [G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163])]; row[offsets.auxiliaries + 160] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = [G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166])]; row[offsets.auxiliaries + 163] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = [G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169])]; row[offsets.auxiliaries + 166] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = [G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172])]; row[offsets.auxiliaries + 169] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = [G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175])]; row[offsets.auxiliaries + 172] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = [G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178])]; row[offsets.auxiliaries + 175] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = [G::from_u64(seed[179]), G::from_u64(seed[180]), G::from_u64(seed[181])]; row[offsets.auxiliaries + 178] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = [G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184])]; row[offsets.auxiliaries + 181] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = [G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187])]; row[offsets.auxiliaries + 184] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = [G::from_u64(seed[188]), G::from_u64(seed[189]), G::from_u64(seed[190])]; row[offsets.auxiliaries + 187] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = [G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193])]; row[offsets.auxiliaries + 190] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_192.as_canonical_u64(); match v_190.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(76, v_190)) }, } }, _ => { Err(no_match(76, v_187)) }, } }, _ => { Err(no_match(76, v_184)) }, } }, _ => { Err(no_match(76, v_181)) }, } }, _ => { Err(no_match(76, v_178)) }, } }, _ => { Err(no_match(76, v_175)) }, } }, _ => { Err(no_match(76, v_172)) }, } }, _ => { Err(no_match(76, v_169)) }, } }, _ => { Err(no_match(76, v_166)) }, } }, _ => { Err(no_match(76, v_163)) }, } }, _ => { Err(no_match(76, v_160)) }, } }, _ => { Err(no_match(76, v_157)) }, } }, _ => { Err(no_match(76, v_154)) }, } }, _ => { Err(no_match(76, v_151)) }, } }, _ => { Err(no_match(76, v_148)) }, } }, _ => { Err(no_match(76, v_145)) }, } }, _ => { Err(no_match(76, v_142)) }, } }, _ => { Err(no_match(76, v_139)) }, } }, _ => { Err(no_match(76, v_136)) }, } }, _ => { Err(no_match(76, v_133)) }, } }, _ => { Err(no_match(76, v_130)) }, } }, _ => { Err(no_match(76, v_127)) }, } }, _ => { Err(no_match(76, v_124)) }, } }, _ => { Err(no_match(76, v_121)) }, } }, _ => { Err(no_match(76, v_118)) }, } }, _ => { Err(no_match(76, v_115)) }, } }, _ => { Err(no_match(76, v_112)) }, } }, _ => { Err(no_match(76, v_109)) }, } }, _ => { Err(no_match(76, v_106)) }, } }, _ => { Err(no_match(76, v_103)) }, } }, _ => { Err(no_match(76, v_100)) }, } }, _ => { Err(no_match(76, v_97)) }, } }, _ => { Err(no_match(76, v_94)) }, } }, _ => { Err(no_match(76, v_91)) }, } }, _ => { Err(no_match(76, v_88)) }, } }, _ => { Err(no_match(76, v_85)) }, } }, _ => { Err(no_match(76, v_82)) }, } }, _ => { Err(no_match(76, v_79)) }, } }, _ => { Err(no_match(76, v_76)) }, } }, _ => { Err(no_match(76, v_73)) }, } }, _ => { Err(no_match(76, v_70)) }, } }, _ => { Err(no_match(76, v_67)) }, } }, _ => { Err(no_match(76, v_64)) }, } }, _ => { Err(no_match(76, v_61)) }, } }, _ => { Err(no_match(76, v_58)) }, } }, _ => { Err(no_match(76, v_55)) }, } }, _ => { Err(no_match(76, v_52)) }, } }, _ => { Err(no_match(76, v_49)) }, } }, _ => { Err(no_match(76, v_46)) }, } }, _ => { Err(no_match(76, v_43)) }, } }, _ => { Err(no_match(76, v_40)) }, } }, _ => { Err(no_match(76, v_37)) }, } }, _ => { Err(no_match(76, v_34)) }, } }, _ => { Err(no_match(76, v_31)) }, } }, _ => { Err(no_match(76, v_28)) }, } }, _ => { Err(no_match(76, v_25)) }, } }, _ => { Err(no_match(76, v_22)) }, } }, _ => { Err(no_match(76, v_19)) }, } }, _ => { Err(no_match(76, v_16)) }, } }, _ => { Err(no_match(76, v_13)) }, } }, _ => { Err(no_match(76, v_10)) }, } }, _ => { Err(no_match(76, v_7)) }, } }, _ => { Err(no_match(76, v_4)) }, } }, _ => { Err(no_match(76, v_1)) }, } } + +static SCHEMA_76: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 528, 784, 8, 532, 785, 16, 536, 786, 24, 540, 787, 32, 544, 788, 40, 548, 789, 48, 552, 790, 56, 556, 791, 64, 560, 792, 72, 564, 793, 80, 568, 794, 88, 572, 795, 96, 576, 796, 104, 580, 797, 112, 584, 798, 120, 588, 799, 128, 592, 800, 136, 596, 801, 144, 600, 802, 152, 604, 803, 160, 608, 804, 168, 612, 805, 176, 616, 806, 184, 620, 807, 192, 624, 808, 200, 628, 809, 208, 632, 810, 216, 636, 811, 224, 640, 812, 232, 644, 813, 240, 648, 814, 248, 652, 815, 256, 656, 816, 264, 660, 817, 272, 664, 818, 280, 668, 819, 288, 672, 820, 296, 676, 821, 304, 680, 822, 312, 684, 823, 320, 688, 824, 328, 692, 825, 336, 696, 826, 344, 700, 827, 352, 704, 828, 360, 708, 829, 368, 712, 830, 376, 716, 831, 384, 720, 832, 392, 724, 833, 400, 728, 834, 408, 732, 835, 416, 736, 836, 424, 740, 837, 432, 744, 838, 440, 748, 839, 448, 752, 840, 456, 756, 841, 464, 760, 842, 472, 764, 843, 480, 768, 844, 488, 772, 845, 496, 776, 846, 504, 780, 847, 512, 520], bytes: 848 }; + +fn pack_78(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; match v_1.as_canonical_u64() { 0u64 => { match v_2.as_canonical_u64() { 0u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 8] = context.load::<8>(3, v_3)?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { match v_10.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { 0u64 => { match v_12.as_canonical_u64() { 0u64 => { match v_13.as_canonical_u64() { 0u64 => { match v_14.as_canonical_u64() { 0u64 => { match v_15.as_canonical_u64() { 0u64 => { match v_16.as_canonical_u64() { 0u64 => { let [v_17]: [G; 1] = [v_6 + v_7]; let [v_18]: [G; 1] = [v_8 + v_17]; let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(6, v_4)?; seed[15] = v_19.as_canonical_u64(); seed[16] = v_20.as_canonical_u64(); seed[17] = v_21.as_canonical_u64(); seed[18] = v_22.as_canonical_u64(); seed[19] = v_23.as_canonical_u64(); seed[20] = v_24.as_canonical_u64(); seed[21] = v_25.as_canonical_u64(); seed[22] = v_26.as_canonical_u64(); seed[23] = v_27.as_canonical_u64(); seed[24] = v_28.as_canonical_u64(); seed[25] = v_29.as_canonical_u64(); seed[26] = v_30.as_canonical_u64(); seed[27] = v_31.as_canonical_u64(); seed[28] = v_32.as_canonical_u64(); seed[29] = v_33.as_canonical_u64(); seed[30] = v_34.as_canonical_u64(); seed[31] = v_35.as_canonical_u64(); seed[32] = v_36.as_canonical_u64(); seed[33] = v_37.as_canonical_u64(); seed[34] = v_38.as_canonical_u64(); seed[35] = v_39.as_canonical_u64(); seed[36] = v_40.as_canonical_u64(); seed[37] = v_41.as_canonical_u64(); seed[38] = v_42.as_canonical_u64(); seed[39] = v_43.as_canonical_u64(); seed[40] = v_44.as_canonical_u64(); seed[41] = v_45.as_canonical_u64(); seed[42] = v_46.as_canonical_u64(); seed[43] = v_47.as_canonical_u64(); seed[44] = v_48.as_canonical_u64(); seed[45] = v_49.as_canonical_u64(); seed[46] = v_50.as_canonical_u64(); let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.load::<8>(8, v_3)?; seed[47] = v_52.as_canonical_u64(); seed[48] = v_53.as_canonical_u64(); seed[49] = v_54.as_canonical_u64(); seed[50] = v_55.as_canonical_u64(); seed[51] = v_56.as_canonical_u64(); seed[52] = v_57.as_canonical_u64(); seed[53] = v_58.as_canonical_u64(); seed[54] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(103)]; let [v_61]: [G; 1] = [G::from_u64(230)]; let [v_62]: [G; 1] = [G::from_u64(9)]; let [v_63]: [G; 1] = [G::from_u64(106)]; let [v_64]: [G; 1] = [G::from_u64(133)]; let [v_65]: [G; 1] = [G::from_u64(174)]; let [v_66]: [G; 1] = [G::from_u64(187)]; let [v_67]: [G; 1] = [G::from_u64(114)]; let [v_68]: [G; 1] = [G::from_u64(243)]; let [v_69]: [G; 1] = [G::from_u64(110)]; let [v_70]: [G; 1] = [G::from_u64(60)]; let [v_71]: [G; 1] = [G::from_u64(58)]; let [v_72]: [G; 1] = [G::from_u64(245)]; let [v_73]: [G; 1] = [G::from_u64(79)]; let [v_74]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(24, 83, &[v_51, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_60, v_61, v_62, v_63, v_64, v_65, v_60, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_51, v_51, v_51, v_51, v_18, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51])?; seed[55] = v_75.as_canonical_u64(); seed[56] = v_76.as_canonical_u64(); seed[57] = v_77.as_canonical_u64(); seed[58] = v_78.as_canonical_u64(); seed[59] = v_79.as_canonical_u64(); seed[60] = v_80.as_canonical_u64(); seed[61] = v_81.as_canonical_u64(); seed[62] = v_82.as_canonical_u64(); seed[63] = v_83.as_canonical_u64(); seed[64] = v_84.as_canonical_u64(); seed[65] = v_85.as_canonical_u64(); seed[66] = v_86.as_canonical_u64(); seed[67] = v_87.as_canonical_u64(); seed[68] = v_88.as_canonical_u64(); seed[69] = v_89.as_canonical_u64(); seed[70] = v_90.as_canonical_u64(); seed[71] = v_91.as_canonical_u64(); seed[72] = v_92.as_canonical_u64(); seed[73] = v_93.as_canonical_u64(); seed[74] = v_94.as_canonical_u64(); seed[75] = v_95.as_canonical_u64(); seed[76] = v_96.as_canonical_u64(); seed[77] = v_97.as_canonical_u64(); seed[78] = v_98.as_canonical_u64(); seed[79] = v_99.as_canonical_u64(); seed[80] = v_100.as_canonical_u64(); seed[81] = v_101.as_canonical_u64(); seed[82] = v_102.as_canonical_u64(); seed[83] = v_103.as_canonical_u64(); seed[84] = v_104.as_canonical_u64(); seed[85] = v_105.as_canonical_u64(); seed[86] = v_106.as_canonical_u64(); let [v_107]: [G; 1] = context.store(25, &[v_51, v_5, 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])?; seed[87] = v_107.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_108]: [G; 1] = [G::from_u64(0)]; let [v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140]: [G; 32] = context.load::<32>(27, v_4)?; seed[7] = v_109.as_canonical_u64(); seed[8] = v_110.as_canonical_u64(); seed[9] = v_111.as_canonical_u64(); seed[10] = v_112.as_canonical_u64(); seed[11] = v_113.as_canonical_u64(); seed[12] = v_114.as_canonical_u64(); seed[13] = v_115.as_canonical_u64(); seed[14] = v_116.as_canonical_u64(); seed[15] = v_117.as_canonical_u64(); seed[16] = v_118.as_canonical_u64(); seed[17] = v_119.as_canonical_u64(); seed[18] = v_120.as_canonical_u64(); seed[19] = v_121.as_canonical_u64(); seed[20] = v_122.as_canonical_u64(); seed[21] = v_123.as_canonical_u64(); seed[22] = v_124.as_canonical_u64(); seed[23] = v_125.as_canonical_u64(); seed[24] = v_126.as_canonical_u64(); seed[25] = v_127.as_canonical_u64(); seed[26] = v_128.as_canonical_u64(); seed[27] = v_129.as_canonical_u64(); seed[28] = v_130.as_canonical_u64(); seed[29] = v_131.as_canonical_u64(); seed[30] = v_132.as_canonical_u64(); seed[31] = v_133.as_canonical_u64(); seed[32] = v_134.as_canonical_u64(); seed[33] = v_135.as_canonical_u64(); seed[34] = v_136.as_canonical_u64(); seed[35] = v_137.as_canonical_u64(); seed[36] = v_138.as_canonical_u64(); seed[37] = v_139.as_canonical_u64(); seed[38] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = context.store(28, &[v_108, v_5, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140])?; seed[39] = v_141.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = context.load::<8>(29, v_3)?; seed[7] = v_142.as_canonical_u64(); seed[8] = v_143.as_canonical_u64(); seed[9] = v_144.as_canonical_u64(); seed[10] = v_145.as_canonical_u64(); seed[11] = v_146.as_canonical_u64(); seed[12] = v_147.as_canonical_u64(); seed[13] = v_148.as_canonical_u64(); seed[14] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = context.call::<1>(30, 2, &[v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149])?; seed[15] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_150 * v_8]; let [v_152]: [G; 1] = [v_2 - v_1]; let [v_153]: [G; 1] = [G::from_bool(v_152.is_zero())]; let [v_154]: [G; 1] = [v_153 * v_6]; let [v_155]: [G; 1] = [v_151 + v_154]; let [v_156]: [G; 1] = [v_7 + v_155]; let [v_157]: [G; 1] = [G::from_u64(64)]; let [v_158]: [G; 1] = [v_157 - v_1]; let [v_159]: [G; 1] = context.call::<1>(39, 77, &[v_0, v_158])?; seed[16] = v_159.as_canonical_u64(); let [v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223]: [G; 64] = context.call::<64>(40, 76, &[v_159])?; seed[17] = v_160.as_canonical_u64(); seed[18] = v_161.as_canonical_u64(); seed[19] = v_162.as_canonical_u64(); seed[20] = v_163.as_canonical_u64(); seed[21] = v_164.as_canonical_u64(); seed[22] = v_165.as_canonical_u64(); seed[23] = v_166.as_canonical_u64(); seed[24] = v_167.as_canonical_u64(); seed[25] = v_168.as_canonical_u64(); seed[26] = v_169.as_canonical_u64(); seed[27] = v_170.as_canonical_u64(); seed[28] = v_171.as_canonical_u64(); seed[29] = v_172.as_canonical_u64(); seed[30] = v_173.as_canonical_u64(); seed[31] = v_174.as_canonical_u64(); seed[32] = v_175.as_canonical_u64(); seed[33] = v_176.as_canonical_u64(); seed[34] = v_177.as_canonical_u64(); seed[35] = v_178.as_canonical_u64(); seed[36] = v_179.as_canonical_u64(); seed[37] = v_180.as_canonical_u64(); seed[38] = v_181.as_canonical_u64(); seed[39] = v_182.as_canonical_u64(); seed[40] = v_183.as_canonical_u64(); seed[41] = v_184.as_canonical_u64(); seed[42] = v_185.as_canonical_u64(); seed[43] = v_186.as_canonical_u64(); seed[44] = v_187.as_canonical_u64(); seed[45] = v_188.as_canonical_u64(); seed[46] = v_189.as_canonical_u64(); seed[47] = v_190.as_canonical_u64(); seed[48] = v_191.as_canonical_u64(); seed[49] = v_192.as_canonical_u64(); seed[50] = v_193.as_canonical_u64(); seed[51] = v_194.as_canonical_u64(); seed[52] = v_195.as_canonical_u64(); seed[53] = v_196.as_canonical_u64(); seed[54] = v_197.as_canonical_u64(); seed[55] = v_198.as_canonical_u64(); seed[56] = v_199.as_canonical_u64(); seed[57] = v_200.as_canonical_u64(); seed[58] = v_201.as_canonical_u64(); seed[59] = v_202.as_canonical_u64(); seed[60] = v_203.as_canonical_u64(); seed[61] = v_204.as_canonical_u64(); seed[62] = v_205.as_canonical_u64(); seed[63] = v_206.as_canonical_u64(); seed[64] = v_207.as_canonical_u64(); seed[65] = v_208.as_canonical_u64(); seed[66] = v_209.as_canonical_u64(); seed[67] = v_210.as_canonical_u64(); seed[68] = v_211.as_canonical_u64(); seed[69] = v_212.as_canonical_u64(); seed[70] = v_213.as_canonical_u64(); seed[71] = v_214.as_canonical_u64(); seed[72] = v_215.as_canonical_u64(); seed[73] = v_216.as_canonical_u64(); seed[74] = v_217.as_canonical_u64(); seed[75] = v_218.as_canonical_u64(); seed[76] = v_219.as_canonical_u64(); seed[77] = v_220.as_canonical_u64(); seed[78] = v_221.as_canonical_u64(); seed[79] = v_222.as_canonical_u64(); seed[80] = v_223.as_canonical_u64(); let [v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_224.as_canonical_u64(); seed[82] = v_225.as_canonical_u64(); seed[83] = v_226.as_canonical_u64(); seed[84] = v_227.as_canonical_u64(); seed[85] = v_228.as_canonical_u64(); seed[86] = v_229.as_canonical_u64(); seed[87] = v_230.as_canonical_u64(); seed[88] = v_231.as_canonical_u64(); seed[89] = v_232.as_canonical_u64(); seed[90] = v_233.as_canonical_u64(); seed[91] = v_234.as_canonical_u64(); seed[92] = v_235.as_canonical_u64(); seed[93] = v_236.as_canonical_u64(); seed[94] = v_237.as_canonical_u64(); seed[95] = v_238.as_canonical_u64(); seed[96] = v_239.as_canonical_u64(); seed[97] = v_240.as_canonical_u64(); seed[98] = v_241.as_canonical_u64(); seed[99] = v_242.as_canonical_u64(); seed[100] = v_243.as_canonical_u64(); seed[101] = v_244.as_canonical_u64(); seed[102] = v_245.as_canonical_u64(); seed[103] = v_246.as_canonical_u64(); seed[104] = v_247.as_canonical_u64(); seed[105] = v_248.as_canonical_u64(); seed[106] = v_249.as_canonical_u64(); seed[107] = v_250.as_canonical_u64(); seed[108] = v_251.as_canonical_u64(); seed[109] = v_252.as_canonical_u64(); seed[110] = v_253.as_canonical_u64(); seed[111] = v_254.as_canonical_u64(); seed[112] = v_255.as_canonical_u64(); let [v_256]: [G; 1] = [G::from_u64(103)]; let [v_257]: [G; 1] = [G::from_u64(230)]; let [v_258]: [G; 1] = [G::from_u64(9)]; let [v_259]: [G; 1] = [G::from_u64(106)]; let [v_260]: [G; 1] = [G::from_u64(133)]; let [v_261]: [G; 1] = [G::from_u64(174)]; let [v_262]: [G; 1] = [G::from_u64(187)]; let [v_263]: [G; 1] = [G::from_u64(114)]; let [v_264]: [G; 1] = [G::from_u64(243)]; let [v_265]: [G; 1] = [G::from_u64(110)]; let [v_266]: [G; 1] = [G::from_u64(60)]; let [v_267]: [G; 1] = [G::from_u64(58)]; let [v_268]: [G; 1] = [G::from_u64(245)]; let [v_269]: [G; 1] = [G::from_u64(79)]; let [v_270]: [G; 1] = [G::from_u64(165)]; let [v_271]: [G; 1] = [G::from_u64(0)]; let [v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303]: [G; 32] = context.call::<32>(58, 83, &[v_271, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, 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_256, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_1, v_271, v_271, v_271, v_156, v_271, v_271, v_271, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223])?; seed[113] = v_272.as_canonical_u64(); seed[114] = v_273.as_canonical_u64(); seed[115] = v_274.as_canonical_u64(); seed[116] = v_275.as_canonical_u64(); seed[117] = v_276.as_canonical_u64(); seed[118] = v_277.as_canonical_u64(); seed[119] = v_278.as_canonical_u64(); seed[120] = v_279.as_canonical_u64(); seed[121] = v_280.as_canonical_u64(); seed[122] = v_281.as_canonical_u64(); seed[123] = v_282.as_canonical_u64(); seed[124] = v_283.as_canonical_u64(); seed[125] = v_284.as_canonical_u64(); seed[126] = v_285.as_canonical_u64(); seed[127] = v_286.as_canonical_u64(); seed[128] = v_287.as_canonical_u64(); seed[129] = v_288.as_canonical_u64(); seed[130] = v_289.as_canonical_u64(); seed[131] = v_290.as_canonical_u64(); seed[132] = v_291.as_canonical_u64(); seed[133] = v_292.as_canonical_u64(); seed[134] = v_293.as_canonical_u64(); seed[135] = v_294.as_canonical_u64(); seed[136] = v_295.as_canonical_u64(); seed[137] = v_296.as_canonical_u64(); seed[138] = v_297.as_canonical_u64(); seed[139] = v_298.as_canonical_u64(); seed[140] = v_299.as_canonical_u64(); seed[141] = v_300.as_canonical_u64(); seed[142] = v_301.as_canonical_u64(); seed[143] = v_302.as_canonical_u64(); seed[144] = v_303.as_canonical_u64(); let [v_304]: [G; 1] = context.store(59, &[v_271, v_5, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303])?; seed[145] = v_304.as_canonical_u64(); Ok(()) }, } } + +fn pack_78_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; match v_1.as_canonical_u64() { 0u64 => { match v_2.as_canonical_u64() { 0u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 8] = context.load::<8>(3, v_3)?; seed.full(32, v_9); seed.full(40, v_10); seed.full(48, v_11); seed.full(56, v_12); seed.full(64, v_13); seed.full(72, v_14); seed.full(80, v_15); seed.full(88, v_16); match v_9.as_canonical_u64() { 0u64 => { match v_10.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { 0u64 => { match v_12.as_canonical_u64() { 0u64 => { match v_13.as_canonical_u64() { 0u64 => { match v_14.as_canonical_u64() { 0u64 => { match v_15.as_canonical_u64() { 0u64 => { match v_16.as_canonical_u64() { 0u64 => { let [v_17]: [G; 1] = [v_6 + v_7]; let [v_18]: [G; 1] = [v_8 + v_17]; let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(6, v_4)?; seed.full(96, v_19); seed.full(104, v_20); seed.full(112, v_21); seed.full(120, v_22); seed.full(128, v_23); seed.full(136, v_24); seed.full(144, v_25); seed.full(152, v_26); seed.full(160, v_27); seed.full(168, v_28); seed.full(176, v_29); seed.full(184, v_30); seed.full(192, v_31); seed.full(200, v_32); seed.full(208, v_33); seed.full(216, v_34); seed.full(224, v_35); seed.full(232, v_36); seed.full(240, v_37); seed.full(248, v_38); seed.full(256, v_39); seed.full(264, v_40); seed.full(272, v_41); seed.full(280, v_42); seed.u32(296, v_43); seed.u8(309, v_44); seed.u8(310, v_45); seed.u8(311, v_46); seed.u8(312, v_47); seed.u8(313, v_48); seed.u8(314, v_49); seed.u8(315, v_50); let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.load::<8>(8, v_3)?; seed.u8(316, v_52); seed.u8(317, v_53); seed.u8(318, v_54); seed.u8(319, v_55); seed.u8(320, v_56); seed.u8(321, v_57); seed.u8(322, v_58); seed.u8(323, v_59); let [v_60]: [G; 1] = [G::from_u64(103)]; let [v_61]: [G; 1] = [G::from_u64(230)]; let [v_62]: [G; 1] = [G::from_u64(9)]; let [v_63]: [G; 1] = [G::from_u64(106)]; let [v_64]: [G; 1] = [G::from_u64(133)]; let [v_65]: [G; 1] = [G::from_u64(174)]; let [v_66]: [G; 1] = [G::from_u64(187)]; let [v_67]: [G; 1] = [G::from_u64(114)]; let [v_68]: [G; 1] = [G::from_u64(243)]; let [v_69]: [G; 1] = [G::from_u64(110)]; let [v_70]: [G; 1] = [G::from_u64(60)]; let [v_71]: [G; 1] = [G::from_u64(58)]; let [v_72]: [G; 1] = [G::from_u64(245)]; let [v_73]: [G; 1] = [G::from_u64(79)]; let [v_74]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(24, 83, &[v_51, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_60, v_61, v_62, v_63, v_64, v_65, v_60, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_51, v_51, v_51, v_51, v_18, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51])?; seed.u8(324, v_75); seed.u8(325, v_76); seed.u8(326, v_77); seed.u8(327, v_78); seed.u8(328, v_79); seed.u8(329, v_80); seed.u8(330, v_81); seed.u8(331, v_82); seed.u8(332, v_83); seed.u8(333, v_84); seed.u8(334, v_85); seed.u8(335, v_86); seed.u8(336, v_87); seed.u8(337, v_88); seed.u8(338, v_89); seed.u8(339, v_90); seed.u8(340, v_91); seed.u8(341, v_92); seed.u8(342, v_93); seed.u8(343, v_94); seed.u8(344, v_95); seed.u8(345, v_96); seed.u8(346, v_97); seed.u8(347, v_98); seed.u8(348, v_99); seed.u8(349, v_100); seed.u8(350, v_101); seed.u8(351, v_102); seed.u8(352, v_103); seed.u8(353, v_104); seed.u8(354, v_105); seed.u8(355, v_106); let [v_107]: [G; 1] = context.store(25, &[v_51, v_5, 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])?; seed.u32(300, v_107); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_108]: [G; 1] = [G::from_u64(0)]; let [v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140]: [G; 32] = context.load::<32>(27, v_4)?; seed.full(32, v_109); seed.full(40, v_110); seed.full(48, v_111); seed.full(56, v_112); seed.full(64, v_113); seed.full(72, v_114); seed.full(80, v_115); seed.full(88, v_116); seed.full(96, v_117); seed.full(104, v_118); seed.full(112, v_119); seed.full(120, v_120); seed.full(128, v_121); seed.full(136, v_122); seed.full(144, v_123); seed.full(152, v_124); seed.full(160, v_125); seed.full(168, v_126); seed.full(176, v_127); seed.full(184, v_128); seed.full(192, v_129); seed.full(200, v_130); seed.full(208, v_131); seed.full(216, v_132); seed.full(224, v_133); seed.full(232, v_134); seed.full(240, v_135); seed.full(248, v_136); seed.full(256, v_137); seed.full(264, v_138); seed.full(272, v_139); seed.full(280, v_140); let [v_141]: [G; 1] = context.store(28, &[v_108, v_5, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140])?; seed.u32(296, v_141); Ok(()) }, } }, _ => { let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = context.load::<8>(29, v_3)?; seed.full(32, v_142); seed.full(40, v_143); seed.full(48, v_144); seed.full(56, v_145); seed.full(64, v_146); seed.full(72, v_147); seed.full(80, v_148); seed.full(88, v_149); let [v_150]: [G; 1] = context.call::<1>(30, 2, &[v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149])?; seed.full(96, v_150); let [v_151]: [G; 1] = [v_150 * v_8]; let [v_152]: [G; 1] = [v_2 - v_1]; let [v_153]: [G; 1] = [G::from_bool(v_152.is_zero())]; let [v_154]: [G; 1] = [v_153 * v_6]; let [v_155]: [G; 1] = [v_151 + v_154]; let [v_156]: [G; 1] = [v_7 + v_155]; let [v_157]: [G; 1] = [G::from_u64(64)]; let [v_158]: [G; 1] = [v_157 - v_1]; let [v_159]: [G; 1] = context.call::<1>(39, 77, &[v_0, v_158])?; seed.full(104, v_159); let [v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223]: [G; 64] = context.call::<64>(40, 76, &[v_159])?; seed.full(112, v_160); seed.full(120, v_161); seed.full(128, v_162); seed.full(136, v_163); seed.full(144, v_164); seed.full(152, v_165); seed.full(160, v_166); seed.full(168, v_167); seed.full(176, v_168); seed.full(184, v_169); seed.full(192, v_170); seed.full(200, v_171); seed.full(208, v_172); seed.full(216, v_173); seed.full(224, v_174); seed.full(232, v_175); seed.full(240, v_176); seed.full(248, v_177); seed.full(256, v_178); seed.full(264, v_179); seed.full(272, v_180); seed.full(280, v_181); seed.u32(296, v_182); seed.u8(309, v_183); seed.u8(310, v_184); seed.u8(311, v_185); seed.u8(312, v_186); seed.u8(313, v_187); seed.u8(314, v_188); seed.u8(315, v_189); seed.u8(316, v_190); seed.u8(317, v_191); seed.u8(318, v_192); seed.u8(319, v_193); seed.u8(320, v_194); seed.u8(321, v_195); seed.u8(322, v_196); seed.u8(323, v_197); seed.u8(324, v_198); seed.u8(325, v_199); seed.u8(326, v_200); seed.u8(327, v_201); seed.u8(328, v_202); seed.u8(329, v_203); seed.u8(330, v_204); seed.u8(331, v_205); seed.u8(332, v_206); seed.u8(333, v_207); seed.u8(334, v_208); seed.u8(335, v_209); seed.u8(336, v_210); seed.u8(337, v_211); seed.u8(338, v_212); seed.u8(339, v_213); seed.u8(340, v_214); seed.u8(341, v_215); seed.u8(342, v_216); seed.u8(343, v_217); seed.u8(344, v_218); seed.u8(345, v_219); seed.u8(346, v_220); seed.u8(347, v_221); seed.u8(348, v_222); seed.u8(349, v_223); let [v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255]: [G; 32] = context.load::<32>(41, v_4)?; seed.u8(350, v_224); seed.u8(351, v_225); seed.u8(352, v_226); seed.u8(353, v_227); seed.u8(354, v_228); seed.u8(355, v_229); seed.u32(300, v_230); seed.u8(356, v_231); seed.u8(357, v_232); seed.u8(358, v_233); seed.u8(359, v_234); seed.u8(360, v_235); seed.u8(361, v_236); seed.u8(362, v_237); seed.u8(363, v_238); seed.u8(364, v_239); seed.u8(365, v_240); seed.u8(366, v_241); seed.u8(367, v_242); seed.u8(368, v_243); seed.u8(369, v_244); seed.u8(370, v_245); seed.u8(371, v_246); seed.u8(372, v_247); seed.u8(373, v_248); seed.u8(374, v_249); seed.u8(375, v_250); seed.u8(376, v_251); seed.u8(377, v_252); seed.u8(378, v_253); seed.u8(379, v_254); seed.u8(380, v_255); let [v_256]: [G; 1] = [G::from_u64(103)]; let [v_257]: [G; 1] = [G::from_u64(230)]; let [v_258]: [G; 1] = [G::from_u64(9)]; let [v_259]: [G; 1] = [G::from_u64(106)]; let [v_260]: [G; 1] = [G::from_u64(133)]; let [v_261]: [G; 1] = [G::from_u64(174)]; let [v_262]: [G; 1] = [G::from_u64(187)]; let [v_263]: [G; 1] = [G::from_u64(114)]; let [v_264]: [G; 1] = [G::from_u64(243)]; let [v_265]: [G; 1] = [G::from_u64(110)]; let [v_266]: [G; 1] = [G::from_u64(60)]; let [v_267]: [G; 1] = [G::from_u64(58)]; let [v_268]: [G; 1] = [G::from_u64(245)]; let [v_269]: [G; 1] = [G::from_u64(79)]; let [v_270]: [G; 1] = [G::from_u64(165)]; let [v_271]: [G; 1] = [G::from_u64(0)]; let [v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303]: [G; 32] = context.call::<32>(58, 83, &[v_271, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, 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_256, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_1, v_271, v_271, v_271, v_156, v_271, v_271, v_271, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223])?; seed.u8(381, v_272); seed.u8(382, v_273); seed.u8(383, v_274); seed.u8(384, v_275); seed.u8(385, v_276); seed.u8(386, v_277); seed.u8(387, v_278); seed.u8(388, v_279); seed.u8(389, v_280); seed.u8(390, v_281); seed.u8(391, v_282); seed.u8(392, v_283); seed.u8(393, v_284); seed.u8(394, v_285); seed.u8(395, v_286); seed.u8(396, v_287); seed.u8(397, v_288); seed.u8(398, v_289); seed.u8(399, v_290); seed.u8(400, v_291); seed.u8(401, v_292); seed.u8(402, v_293); seed.u8(403, v_294); seed.u8(404, v_295); seed.u8(405, v_296); seed.u8(406, v_297); seed.u8(407, v_298); seed.u8(408, v_299); seed.u8(409, v_300); seed.u8(410, v_301); seed.u8(411, v_302); seed.u8(412, v_303); let [v_304]: [G; 1] = context.store(59, &[v_271, v_5, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303])?; seed.u32(304, v_304); Ok(()) }, } } + +fn pack_78_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; match v_1.as_canonical_u64() { 0u64 => { match v_2.as_canonical_u64() { 0u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 8] = context.load::<8>(3, v_3)?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { match v_10.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { 0u64 => { match v_12.as_canonical_u64() { 0u64 => { match v_13.as_canonical_u64() { 0u64 => { match v_14.as_canonical_u64() { 0u64 => { match v_15.as_canonical_u64() { 0u64 => { match v_16.as_canonical_u64() { 0u64 => { let [v_17]: [G; 1] = [v_6 + v_7]; let [v_18]: [G; 1] = [v_8 + v_17]; let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(6, v_4)?; seed[15] = v_19.as_canonical_u64(); seed[16] = v_20.as_canonical_u64(); seed[17] = v_21.as_canonical_u64(); seed[18] = v_22.as_canonical_u64(); seed[19] = v_23.as_canonical_u64(); seed[20] = v_24.as_canonical_u64(); seed[21] = v_25.as_canonical_u64(); seed[22] = v_26.as_canonical_u64(); seed[23] = v_27.as_canonical_u64(); seed[24] = v_28.as_canonical_u64(); seed[25] = v_29.as_canonical_u64(); seed[26] = v_30.as_canonical_u64(); seed[27] = v_31.as_canonical_u64(); seed[28] = v_32.as_canonical_u64(); seed[29] = v_33.as_canonical_u64(); seed[30] = v_34.as_canonical_u64(); seed[31] = v_35.as_canonical_u64(); seed[32] = v_36.as_canonical_u64(); seed[33] = v_37.as_canonical_u64(); seed[34] = v_38.as_canonical_u64(); seed[35] = v_39.as_canonical_u64(); seed[36] = v_40.as_canonical_u64(); seed[37] = v_41.as_canonical_u64(); seed[38] = v_42.as_canonical_u64(); seed[39] = v_43.as_canonical_u64(); seed[40] = v_44.as_canonical_u64(); seed[41] = v_45.as_canonical_u64(); seed[42] = v_46.as_canonical_u64(); seed[43] = v_47.as_canonical_u64(); seed[44] = v_48.as_canonical_u64(); seed[45] = v_49.as_canonical_u64(); seed[46] = v_50.as_canonical_u64(); let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.load::<8>(8, v_3)?; seed[47] = v_52.as_canonical_u64(); seed[48] = v_53.as_canonical_u64(); seed[49] = v_54.as_canonical_u64(); seed[50] = v_55.as_canonical_u64(); seed[51] = v_56.as_canonical_u64(); seed[52] = v_57.as_canonical_u64(); seed[53] = v_58.as_canonical_u64(); seed[54] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(103)]; let [v_61]: [G; 1] = [G::from_u64(230)]; let [v_62]: [G; 1] = [G::from_u64(9)]; let [v_63]: [G; 1] = [G::from_u64(106)]; let [v_64]: [G; 1] = [G::from_u64(133)]; let [v_65]: [G; 1] = [G::from_u64(174)]; let [v_66]: [G; 1] = [G::from_u64(187)]; let [v_67]: [G; 1] = [G::from_u64(114)]; let [v_68]: [G; 1] = [G::from_u64(243)]; let [v_69]: [G; 1] = [G::from_u64(110)]; let [v_70]: [G; 1] = [G::from_u64(60)]; let [v_71]: [G; 1] = [G::from_u64(58)]; let [v_72]: [G; 1] = [G::from_u64(245)]; let [v_73]: [G; 1] = [G::from_u64(79)]; let [v_74]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(24, 83, &[v_51, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_60, v_61, v_62, v_63, v_64, v_65, v_60, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_51, v_51, v_51, v_51, v_18, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51])?; seed[55] = v_75.as_canonical_u64(); seed[56] = v_76.as_canonical_u64(); seed[57] = v_77.as_canonical_u64(); seed[58] = v_78.as_canonical_u64(); seed[59] = v_79.as_canonical_u64(); seed[60] = v_80.as_canonical_u64(); seed[61] = v_81.as_canonical_u64(); seed[62] = v_82.as_canonical_u64(); seed[63] = v_83.as_canonical_u64(); seed[64] = v_84.as_canonical_u64(); seed[65] = v_85.as_canonical_u64(); seed[66] = v_86.as_canonical_u64(); seed[67] = v_87.as_canonical_u64(); seed[68] = v_88.as_canonical_u64(); seed[69] = v_89.as_canonical_u64(); seed[70] = v_90.as_canonical_u64(); seed[71] = v_91.as_canonical_u64(); seed[72] = v_92.as_canonical_u64(); seed[73] = v_93.as_canonical_u64(); seed[74] = v_94.as_canonical_u64(); seed[75] = v_95.as_canonical_u64(); seed[76] = v_96.as_canonical_u64(); seed[77] = v_97.as_canonical_u64(); seed[78] = v_98.as_canonical_u64(); seed[79] = v_99.as_canonical_u64(); seed[80] = v_100.as_canonical_u64(); seed[81] = v_101.as_canonical_u64(); seed[82] = v_102.as_canonical_u64(); seed[83] = v_103.as_canonical_u64(); seed[84] = v_104.as_canonical_u64(); seed[85] = v_105.as_canonical_u64(); seed[86] = v_106.as_canonical_u64(); let [v_107]: [G; 1] = context.store(25, &[v_51, v_5, 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])?; seed[87] = v_107.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_108]: [G; 1] = [G::from_u64(0)]; let [v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140]: [G; 32] = context.load::<32>(27, v_4)?; seed[7] = v_109.as_canonical_u64(); seed[8] = v_110.as_canonical_u64(); seed[9] = v_111.as_canonical_u64(); seed[10] = v_112.as_canonical_u64(); seed[11] = v_113.as_canonical_u64(); seed[12] = v_114.as_canonical_u64(); seed[13] = v_115.as_canonical_u64(); seed[14] = v_116.as_canonical_u64(); seed[15] = v_117.as_canonical_u64(); seed[16] = v_118.as_canonical_u64(); seed[17] = v_119.as_canonical_u64(); seed[18] = v_120.as_canonical_u64(); seed[19] = v_121.as_canonical_u64(); seed[20] = v_122.as_canonical_u64(); seed[21] = v_123.as_canonical_u64(); seed[22] = v_124.as_canonical_u64(); seed[23] = v_125.as_canonical_u64(); seed[24] = v_126.as_canonical_u64(); seed[25] = v_127.as_canonical_u64(); seed[26] = v_128.as_canonical_u64(); seed[27] = v_129.as_canonical_u64(); seed[28] = v_130.as_canonical_u64(); seed[29] = v_131.as_canonical_u64(); seed[30] = v_132.as_canonical_u64(); seed[31] = v_133.as_canonical_u64(); seed[32] = v_134.as_canonical_u64(); seed[33] = v_135.as_canonical_u64(); seed[34] = v_136.as_canonical_u64(); seed[35] = v_137.as_canonical_u64(); seed[36] = v_138.as_canonical_u64(); seed[37] = v_139.as_canonical_u64(); seed[38] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = context.store(28, &[v_108, v_5, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140])?; seed[39] = v_141.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = context.load::<8>(29, v_3)?; seed[7] = v_142.as_canonical_u64(); seed[8] = v_143.as_canonical_u64(); seed[9] = v_144.as_canonical_u64(); seed[10] = v_145.as_canonical_u64(); seed[11] = v_146.as_canonical_u64(); seed[12] = v_147.as_canonical_u64(); seed[13] = v_148.as_canonical_u64(); seed[14] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = context.call::<1>(30, 2, &[v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149])?; seed[15] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_150 * v_8]; let [v_152]: [G; 1] = [v_2 - v_1]; let [v_153]: [G; 1] = [G::from_bool(v_152.is_zero())]; let [v_154]: [G; 1] = [v_153 * v_6]; let [v_155]: [G; 1] = [v_151 + v_154]; let [v_156]: [G; 1] = [v_7 + v_155]; let [v_157]: [G; 1] = [G::from_u64(64)]; let [v_158]: [G; 1] = [v_157 - v_1]; let [v_159]: [G; 1] = context.call::<1>(39, 77, &[v_0, v_158])?; seed[16] = v_159.as_canonical_u64(); let [v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223]: [G; 64] = context.call::<64>(40, 76, &[v_159])?; seed[17] = v_160.as_canonical_u64(); seed[18] = v_161.as_canonical_u64(); seed[19] = v_162.as_canonical_u64(); seed[20] = v_163.as_canonical_u64(); seed[21] = v_164.as_canonical_u64(); seed[22] = v_165.as_canonical_u64(); seed[23] = v_166.as_canonical_u64(); seed[24] = v_167.as_canonical_u64(); seed[25] = v_168.as_canonical_u64(); seed[26] = v_169.as_canonical_u64(); seed[27] = v_170.as_canonical_u64(); seed[28] = v_171.as_canonical_u64(); seed[29] = v_172.as_canonical_u64(); seed[30] = v_173.as_canonical_u64(); seed[31] = v_174.as_canonical_u64(); seed[32] = v_175.as_canonical_u64(); seed[33] = v_176.as_canonical_u64(); seed[34] = v_177.as_canonical_u64(); seed[35] = v_178.as_canonical_u64(); seed[36] = v_179.as_canonical_u64(); seed[37] = v_180.as_canonical_u64(); seed[38] = v_181.as_canonical_u64(); seed[39] = v_182.as_canonical_u64(); seed[40] = v_183.as_canonical_u64(); seed[41] = v_184.as_canonical_u64(); seed[42] = v_185.as_canonical_u64(); seed[43] = v_186.as_canonical_u64(); seed[44] = v_187.as_canonical_u64(); seed[45] = v_188.as_canonical_u64(); seed[46] = v_189.as_canonical_u64(); seed[47] = v_190.as_canonical_u64(); seed[48] = v_191.as_canonical_u64(); seed[49] = v_192.as_canonical_u64(); seed[50] = v_193.as_canonical_u64(); seed[51] = v_194.as_canonical_u64(); seed[52] = v_195.as_canonical_u64(); seed[53] = v_196.as_canonical_u64(); seed[54] = v_197.as_canonical_u64(); seed[55] = v_198.as_canonical_u64(); seed[56] = v_199.as_canonical_u64(); seed[57] = v_200.as_canonical_u64(); seed[58] = v_201.as_canonical_u64(); seed[59] = v_202.as_canonical_u64(); seed[60] = v_203.as_canonical_u64(); seed[61] = v_204.as_canonical_u64(); seed[62] = v_205.as_canonical_u64(); seed[63] = v_206.as_canonical_u64(); seed[64] = v_207.as_canonical_u64(); seed[65] = v_208.as_canonical_u64(); seed[66] = v_209.as_canonical_u64(); seed[67] = v_210.as_canonical_u64(); seed[68] = v_211.as_canonical_u64(); seed[69] = v_212.as_canonical_u64(); seed[70] = v_213.as_canonical_u64(); seed[71] = v_214.as_canonical_u64(); seed[72] = v_215.as_canonical_u64(); seed[73] = v_216.as_canonical_u64(); seed[74] = v_217.as_canonical_u64(); seed[75] = v_218.as_canonical_u64(); seed[76] = v_219.as_canonical_u64(); seed[77] = v_220.as_canonical_u64(); seed[78] = v_221.as_canonical_u64(); seed[79] = v_222.as_canonical_u64(); seed[80] = v_223.as_canonical_u64(); let [v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_224.as_canonical_u64(); seed[82] = v_225.as_canonical_u64(); seed[83] = v_226.as_canonical_u64(); seed[84] = v_227.as_canonical_u64(); seed[85] = v_228.as_canonical_u64(); seed[86] = v_229.as_canonical_u64(); seed[87] = v_230.as_canonical_u64(); seed[88] = v_231.as_canonical_u64(); seed[89] = v_232.as_canonical_u64(); seed[90] = v_233.as_canonical_u64(); seed[91] = v_234.as_canonical_u64(); seed[92] = v_235.as_canonical_u64(); seed[93] = v_236.as_canonical_u64(); seed[94] = v_237.as_canonical_u64(); seed[95] = v_238.as_canonical_u64(); seed[96] = v_239.as_canonical_u64(); seed[97] = v_240.as_canonical_u64(); seed[98] = v_241.as_canonical_u64(); seed[99] = v_242.as_canonical_u64(); seed[100] = v_243.as_canonical_u64(); seed[101] = v_244.as_canonical_u64(); seed[102] = v_245.as_canonical_u64(); seed[103] = v_246.as_canonical_u64(); seed[104] = v_247.as_canonical_u64(); seed[105] = v_248.as_canonical_u64(); seed[106] = v_249.as_canonical_u64(); seed[107] = v_250.as_canonical_u64(); seed[108] = v_251.as_canonical_u64(); seed[109] = v_252.as_canonical_u64(); seed[110] = v_253.as_canonical_u64(); seed[111] = v_254.as_canonical_u64(); seed[112] = v_255.as_canonical_u64(); let [v_256]: [G; 1] = [G::from_u64(103)]; let [v_257]: [G; 1] = [G::from_u64(230)]; let [v_258]: [G; 1] = [G::from_u64(9)]; let [v_259]: [G; 1] = [G::from_u64(106)]; let [v_260]: [G; 1] = [G::from_u64(133)]; let [v_261]: [G; 1] = [G::from_u64(174)]; let [v_262]: [G; 1] = [G::from_u64(187)]; let [v_263]: [G; 1] = [G::from_u64(114)]; let [v_264]: [G; 1] = [G::from_u64(243)]; let [v_265]: [G; 1] = [G::from_u64(110)]; let [v_266]: [G; 1] = [G::from_u64(60)]; let [v_267]: [G; 1] = [G::from_u64(58)]; let [v_268]: [G; 1] = [G::from_u64(245)]; let [v_269]: [G; 1] = [G::from_u64(79)]; let [v_270]: [G; 1] = [G::from_u64(165)]; let [v_271]: [G; 1] = [G::from_u64(0)]; let [v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303]: [G; 32] = context.call::<32>(58, 83, &[v_271, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, 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_256, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_1, v_271, v_271, v_271, v_156, v_271, v_271, v_271, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223])?; seed[113] = v_272.as_canonical_u64(); seed[114] = v_273.as_canonical_u64(); seed[115] = v_274.as_canonical_u64(); seed[116] = v_275.as_canonical_u64(); seed[117] = v_276.as_canonical_u64(); seed[118] = v_277.as_canonical_u64(); seed[119] = v_278.as_canonical_u64(); seed[120] = v_279.as_canonical_u64(); seed[121] = v_280.as_canonical_u64(); seed[122] = v_281.as_canonical_u64(); seed[123] = v_282.as_canonical_u64(); seed[124] = v_283.as_canonical_u64(); seed[125] = v_284.as_canonical_u64(); seed[126] = v_285.as_canonical_u64(); seed[127] = v_286.as_canonical_u64(); seed[128] = v_287.as_canonical_u64(); seed[129] = v_288.as_canonical_u64(); seed[130] = v_289.as_canonical_u64(); seed[131] = v_290.as_canonical_u64(); seed[132] = v_291.as_canonical_u64(); seed[133] = v_292.as_canonical_u64(); seed[134] = v_293.as_canonical_u64(); seed[135] = v_294.as_canonical_u64(); seed[136] = v_295.as_canonical_u64(); seed[137] = v_296.as_canonical_u64(); seed[138] = v_297.as_canonical_u64(); seed[139] = v_298.as_canonical_u64(); seed[140] = v_299.as_canonical_u64(); seed[141] = v_300.as_canonical_u64(); seed[142] = v_301.as_canonical_u64(); seed[143] = v_302.as_canonical_u64(); seed[144] = v_303.as_canonical_u64(); let [v_304]: [G; 1] = context.store(59, &[v_271, v_5, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303])?; seed[145] = v_304.as_canonical_u64(); Ok(()) }, } } + +fn write_78(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); match v_1.as_canonical_u64() { 0u64 => { match v_2.as_canonical_u64() { 0u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 8] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { match v_10.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { 0u64 => { match v_12.as_canonical_u64() { 0u64 => { match v_13.as_canonical_u64() { 0u64 => { match v_14.as_canonical_u64() { 0u64 => { match v_15.as_canonical_u64() { 0u64 => { match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 9] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_50.as_canonical_u64(); let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = [G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 41] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_59.as_canonical_u64(); let [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]: [G; 32] = [G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86])]; row[offsets.auxiliaries + 49] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_106.as_canonical_u64(); let [v_107]: [G; 1] = [G::from_u64(seed[87])]; row[offsets.auxiliaries + 81] = v_107.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 9] = (v_16 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_14 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_13 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_12 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_11 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_10 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_9 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 1] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140]: [G; 32] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38])]; row[offsets.auxiliaries + 2] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 34] = v_141.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 2] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 10] = v_150.as_canonical_u64(); let [v_152]: [G; 1] = [v_2 - v_1]; let [v_153]: [G; 1] = [G::from_bool(v_152.is_zero())]; row[offsets.auxiliaries + 11] = g_inverse_value(v_152).as_canonical_u64(); row[offsets.auxiliaries + 12] = v_153.as_canonical_u64(); let [v_159]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 13] = v_159.as_canonical_u64(); let [v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223]: [G; 64] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 14] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_193.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_198.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_199.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_213.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_215.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_223.as_canonical_u64(); let [v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255]: [G; 32] = [G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 78] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_237.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_255.as_canonical_u64(); let [v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303]: [G; 32] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144])]; row[offsets.auxiliaries + 110] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_273.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_274.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_275.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_277.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_279.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_281.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_283.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_284.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_285.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_286.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_287.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_297.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_298.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_299.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_300.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_303.as_canonical_u64(); let [v_304]: [G; 1] = [G::from_u64(seed[145])]; row[offsets.auxiliaries + 142] = v_304.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_78: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 8, 308, 16, 288, 292, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 296, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 300, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 304], bytes: 416 }; + +fn pack_79(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = context.call::<64>(3, 76, &[v_1])?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); seed[47] = v_49.as_canonical_u64(); seed[48] = v_50.as_canonical_u64(); seed[49] = v_51.as_canonical_u64(); seed[50] = v_52.as_canonical_u64(); seed[51] = v_53.as_canonical_u64(); seed[52] = v_54.as_canonical_u64(); seed[53] = v_55.as_canonical_u64(); seed[54] = v_56.as_canonical_u64(); seed[55] = v_57.as_canonical_u64(); seed[56] = v_58.as_canonical_u64(); seed[57] = v_59.as_canonical_u64(); seed[58] = v_60.as_canonical_u64(); seed[59] = v_61.as_canonical_u64(); seed[60] = v_62.as_canonical_u64(); seed[61] = v_63.as_canonical_u64(); seed[62] = v_64.as_canonical_u64(); seed[63] = v_65.as_canonical_u64(); seed[64] = v_66.as_canonical_u64(); seed[65] = v_67.as_canonical_u64(); seed[66] = v_68.as_canonical_u64(); seed[67] = v_69.as_canonical_u64(); seed[68] = v_70.as_canonical_u64(); seed[69] = v_71.as_canonical_u64(); seed[70] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 249, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed[72] = v_74.as_canonical_u64(); seed[73] = v_75.as_canonical_u64(); seed[74] = v_76.as_canonical_u64(); seed[75] = v_77.as_canonical_u64(); seed[76] = v_78.as_canonical_u64(); seed[77] = v_79.as_canonical_u64(); seed[78] = v_80.as_canonical_u64(); seed[79] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(6, 2, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[80] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_117.as_canonical_u64(); seed[82] = v_118.as_canonical_u64(); seed[83] = v_119.as_canonical_u64(); seed[84] = v_120.as_canonical_u64(); seed[85] = v_121.as_canonical_u64(); seed[86] = v_122.as_canonical_u64(); seed[87] = v_123.as_canonical_u64(); seed[88] = v_124.as_canonical_u64(); seed[89] = v_125.as_canonical_u64(); seed[90] = v_126.as_canonical_u64(); seed[91] = v_127.as_canonical_u64(); seed[92] = v_128.as_canonical_u64(); seed[93] = v_129.as_canonical_u64(); seed[94] = v_130.as_canonical_u64(); seed[95] = v_131.as_canonical_u64(); seed[96] = v_132.as_canonical_u64(); seed[97] = v_133.as_canonical_u64(); seed[98] = v_134.as_canonical_u64(); seed[99] = v_135.as_canonical_u64(); seed[100] = v_136.as_canonical_u64(); seed[101] = v_137.as_canonical_u64(); seed[102] = v_138.as_canonical_u64(); seed[103] = v_139.as_canonical_u64(); seed[104] = v_140.as_canonical_u64(); seed[105] = v_141.as_canonical_u64(); seed[106] = v_142.as_canonical_u64(); seed[107] = v_143.as_canonical_u64(); seed[108] = v_144.as_canonical_u64(); seed[109] = v_145.as_canonical_u64(); seed[110] = v_146.as_canonical_u64(); seed[111] = v_147.as_canonical_u64(); seed[112] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 83, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed[113] = v_151.as_canonical_u64(); seed[114] = v_152.as_canonical_u64(); seed[115] = v_153.as_canonical_u64(); seed[116] = v_154.as_canonical_u64(); seed[117] = v_155.as_canonical_u64(); seed[118] = v_156.as_canonical_u64(); seed[119] = v_157.as_canonical_u64(); seed[120] = v_158.as_canonical_u64(); seed[121] = v_159.as_canonical_u64(); seed[122] = v_160.as_canonical_u64(); seed[123] = v_161.as_canonical_u64(); seed[124] = v_162.as_canonical_u64(); seed[125] = v_163.as_canonical_u64(); seed[126] = v_164.as_canonical_u64(); seed[127] = v_165.as_canonical_u64(); seed[128] = v_166.as_canonical_u64(); seed[129] = v_167.as_canonical_u64(); seed[130] = v_168.as_canonical_u64(); seed[131] = v_169.as_canonical_u64(); seed[132] = v_170.as_canonical_u64(); seed[133] = v_171.as_canonical_u64(); seed[134] = v_172.as_canonical_u64(); seed[135] = v_173.as_canonical_u64(); seed[136] = v_174.as_canonical_u64(); seed[137] = v_175.as_canonical_u64(); seed[138] = v_176.as_canonical_u64(); seed[139] = v_177.as_canonical_u64(); seed[140] = v_178.as_canonical_u64(); seed[141] = v_179.as_canonical_u64(); seed[142] = v_180.as_canonical_u64(); seed[143] = v_181.as_canonical_u64(); seed[144] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed[145] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed[146] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 11, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[147] = v_186.as_canonical_u64(); seed[148] = v_187.as_canonical_u64(); seed[149] = v_188.as_canonical_u64(); seed[150] = v_189.as_canonical_u64(); seed[151] = v_190.as_canonical_u64(); seed[152] = v_191.as_canonical_u64(); seed[153] = v_192.as_canonical_u64(); seed[154] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed[155] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, 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])?; seed[156] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed[157] = v_196.as_canonical_u64(); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 249, &[v_0])?; seed[71] = v_197.as_canonical_u64(); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 249, &[v_0])?; seed[72] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed[73] = v_200.as_canonical_u64(); seed[74] = v_201.as_canonical_u64(); seed[75] = v_202.as_canonical_u64(); seed[76] = v_203.as_canonical_u64(); seed[77] = v_204.as_canonical_u64(); seed[78] = v_205.as_canonical_u64(); seed[79] = v_206.as_canonical_u64(); seed[80] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = context.call::<1>(56, 2, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed[81] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed[82] = v_217.as_canonical_u64(); seed[83] = v_218.as_canonical_u64(); seed[84] = v_219.as_canonical_u64(); seed[85] = v_220.as_canonical_u64(); seed[86] = v_221.as_canonical_u64(); seed[87] = v_222.as_canonical_u64(); seed[88] = v_223.as_canonical_u64(); seed[89] = v_224.as_canonical_u64(); seed[90] = v_225.as_canonical_u64(); seed[91] = v_226.as_canonical_u64(); seed[92] = v_227.as_canonical_u64(); seed[93] = v_228.as_canonical_u64(); seed[94] = v_229.as_canonical_u64(); seed[95] = v_230.as_canonical_u64(); seed[96] = v_231.as_canonical_u64(); seed[97] = v_232.as_canonical_u64(); seed[98] = v_233.as_canonical_u64(); seed[99] = v_234.as_canonical_u64(); seed[100] = v_235.as_canonical_u64(); seed[101] = v_236.as_canonical_u64(); seed[102] = v_237.as_canonical_u64(); seed[103] = v_238.as_canonical_u64(); seed[104] = v_239.as_canonical_u64(); seed[105] = v_240.as_canonical_u64(); seed[106] = v_241.as_canonical_u64(); seed[107] = v_242.as_canonical_u64(); seed[108] = v_243.as_canonical_u64(); seed[109] = v_244.as_canonical_u64(); seed[110] = v_245.as_canonical_u64(); seed[111] = v_246.as_canonical_u64(); seed[112] = v_247.as_canonical_u64(); seed[113] = v_248.as_canonical_u64(); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 83, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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])?; seed[114] = v_266.as_canonical_u64(); seed[115] = v_267.as_canonical_u64(); seed[116] = v_268.as_canonical_u64(); seed[117] = v_269.as_canonical_u64(); seed[118] = v_270.as_canonical_u64(); seed[119] = v_271.as_canonical_u64(); seed[120] = v_272.as_canonical_u64(); seed[121] = v_273.as_canonical_u64(); seed[122] = v_274.as_canonical_u64(); seed[123] = v_275.as_canonical_u64(); seed[124] = v_276.as_canonical_u64(); seed[125] = v_277.as_canonical_u64(); seed[126] = v_278.as_canonical_u64(); seed[127] = v_279.as_canonical_u64(); seed[128] = v_280.as_canonical_u64(); seed[129] = v_281.as_canonical_u64(); seed[130] = v_282.as_canonical_u64(); seed[131] = v_283.as_canonical_u64(); seed[132] = v_284.as_canonical_u64(); seed[133] = v_285.as_canonical_u64(); seed[134] = v_286.as_canonical_u64(); seed[135] = v_287.as_canonical_u64(); seed[136] = v_288.as_canonical_u64(); seed[137] = v_289.as_canonical_u64(); seed[138] = v_290.as_canonical_u64(); seed[139] = v_291.as_canonical_u64(); seed[140] = v_292.as_canonical_u64(); seed[141] = v_293.as_canonical_u64(); seed[142] = v_294.as_canonical_u64(); seed[143] = v_295.as_canonical_u64(); seed[144] = v_296.as_canonical_u64(); seed[145] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed[146] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed[147] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed[148] = v_302.as_canonical_u64(); Ok(()) }, } } + +fn pack_79_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = context.call::<64>(3, 76, &[v_1])?; seed.u8(128, v_9); seed.u8(129, v_10); seed.u8(130, v_11); seed.u8(131, v_12); seed.u8(132, v_13); seed.u8(133, v_14); seed.u8(134, v_15); seed.u8(135, v_16); seed.u8(136, v_17); seed.u8(137, v_18); seed.u8(138, v_19); seed.u8(139, v_20); seed.u8(140, v_21); seed.u8(141, v_22); seed.u8(142, v_23); seed.u8(143, v_24); seed.u8(144, v_25); seed.u8(145, v_26); seed.u8(146, v_27); seed.u8(147, v_28); seed.u8(148, v_29); seed.u8(149, v_30); seed.u8(150, v_31); seed.u8(151, v_32); seed.u8(152, v_33); seed.u8(153, v_34); seed.u8(154, v_35); seed.u8(155, v_36); seed.u8(156, v_37); seed.u8(157, v_38); seed.u8(158, v_39); seed.u8(159, v_40); seed.u8(160, v_41); seed.u8(161, v_42); seed.u8(162, v_43); seed.u8(163, v_44); seed.u8(164, v_45); seed.u8(165, v_46); seed.u8(166, v_47); seed.u8(167, v_48); seed.u8(168, v_49); seed.u8(169, v_50); seed.u8(170, v_51); seed.u8(171, v_52); seed.u8(172, v_53); seed.u8(173, v_54); seed.u8(174, v_55); seed.u8(175, v_56); seed.u8(176, v_57); seed.u8(177, v_58); seed.u8(178, v_59); seed.u8(179, v_60); seed.u8(180, v_61); seed.u8(181, v_62); seed.u8(182, v_63); seed.u8(183, v_64); seed.u8(184, v_65); seed.u8(185, v_66); seed.u8(186, v_67); seed.u8(187, v_68); seed.u8(188, v_69); seed.u8(189, v_70); seed.u8(190, v_71); seed.u8(191, v_72); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 249, &[v_0])?; seed.u8(192, v_73); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed.u8(193, v_74); seed.u8(194, v_75); seed.u8(195, v_76); seed.u8(196, v_77); seed.u8(197, v_78); seed.u8(198, v_79); seed.u8(199, v_80); seed.u8(200, v_81); let [v_82]: [G; 1] = context.call::<1>(6, 2, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.u8(201, v_82); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed.u8(202, v_117); seed.u8(203, v_118); seed.u8(204, v_119); seed.u8(205, v_120); seed.u8(206, v_121); seed.u8(207, v_122); seed.u8(208, v_123); seed.u8(209, v_124); seed.u8(210, v_125); seed.u8(211, v_126); seed.u8(212, v_127); seed.u8(213, v_128); seed.u8(214, v_129); seed.u8(215, v_130); seed.u8(216, v_131); seed.u8(217, v_132); seed.u8(218, v_133); seed.u8(219, v_134); seed.u8(220, v_135); seed.u8(221, v_136); seed.u8(222, v_137); seed.u8(223, v_138); seed.u8(224, v_139); seed.u8(225, v_140); seed.u8(226, v_141); seed.u8(227, v_142); seed.u8(228, v_143); seed.u8(229, v_144); seed.u8(230, v_145); seed.u8(231, v_146); seed.u8(232, v_147); seed.u8(233, v_148); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 83, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed.u8(234, v_151); seed.u8(235, v_152); seed.u8(236, v_153); seed.u8(237, v_154); seed.u8(238, v_155); seed.u8(239, v_156); seed.u8(240, v_157); seed.u8(241, v_158); seed.u8(242, v_159); seed.u8(243, v_160); seed.u8(244, v_161); seed.u8(245, v_162); seed.u8(246, v_163); seed.u8(247, v_164); seed.u8(248, v_165); seed.u8(249, v_166); seed.u8(250, v_167); seed.u8(251, v_168); seed.u8(252, v_169); seed.u8(253, v_170); seed.u8(254, v_171); seed.u8(255, v_172); seed.u8(256, v_173); seed.u8(257, v_174); seed.u8(258, v_175); seed.u8(259, v_176); seed.u8(260, v_177); seed.u8(261, v_178); seed.u8(262, v_179); seed.u8(263, v_180); seed.u8(264, v_181); seed.u8(265, v_182); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed.u32(112, v_183); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed.u32(116, v_185); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 11, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.full(24, v_186); seed.full(32, v_187); seed.full(40, v_188); seed.full(48, v_189); seed.full(56, v_190); seed.full(64, v_191); seed.full(72, v_192); seed.full(80, v_193); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed.u32(120, v_194); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, 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])?; seed.u32(124, v_195); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed.full(88, v_196); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 249, &[v_0])?; seed.u8(192, v_197); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 249, &[v_0])?; seed.u8(193, v_199); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed.u8(194, v_200); seed.u8(195, v_201); seed.u8(196, v_202); seed.u8(197, v_203); seed.u8(198, v_204); seed.u8(199, v_205); seed.u8(200, v_206); seed.u8(201, v_207); let [v_208]: [G; 1] = context.call::<1>(56, 2, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed.u8(202, v_208); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed.u8(203, v_217); seed.u8(204, v_218); seed.u8(205, v_219); seed.u8(206, v_220); seed.u8(207, v_221); seed.u8(208, v_222); seed.u8(209, v_223); seed.u8(210, v_224); seed.u8(211, v_225); seed.u8(212, v_226); seed.u8(213, v_227); seed.u8(214, v_228); seed.u8(215, v_229); seed.u8(216, v_230); seed.u8(217, v_231); seed.u8(218, v_232); seed.u8(219, v_233); seed.u8(220, v_234); seed.u8(221, v_235); seed.u8(222, v_236); seed.u8(223, v_237); seed.u8(224, v_238); seed.u8(225, v_239); seed.u8(226, v_240); seed.u8(227, v_241); seed.u8(228, v_242); seed.u8(229, v_243); seed.u8(230, v_244); seed.u8(231, v_245); seed.u8(232, v_246); seed.u8(233, v_247); seed.u8(234, v_248); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 83, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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])?; seed.u8(235, v_266); seed.u8(236, v_267); seed.u8(237, v_268); seed.u8(238, v_269); seed.u8(239, v_270); seed.u8(240, v_271); seed.u8(241, v_272); seed.u8(242, v_273); seed.u8(243, v_274); seed.u8(244, v_275); seed.u8(245, v_276); seed.u8(246, v_277); seed.u8(247, v_278); seed.u8(248, v_279); seed.u8(249, v_280); seed.u8(250, v_281); seed.u8(251, v_282); seed.u8(252, v_283); seed.u8(253, v_284); seed.u8(254, v_285); seed.u8(255, v_286); seed.u8(256, v_287); seed.u8(257, v_288); seed.u8(258, v_289); seed.u8(259, v_290); seed.u8(260, v_291); seed.u8(261, v_292); seed.u8(262, v_293); seed.u8(263, v_294); seed.u8(264, v_295); seed.u8(265, v_296); seed.u32(112, v_297); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed.u32(116, v_299); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed.full(24, v_301); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed.full(32, v_302); Ok(()) }, } } + +fn pack_79_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = context.call::<64>(3, 76, &[v_1])?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); seed[47] = v_49.as_canonical_u64(); seed[48] = v_50.as_canonical_u64(); seed[49] = v_51.as_canonical_u64(); seed[50] = v_52.as_canonical_u64(); seed[51] = v_53.as_canonical_u64(); seed[52] = v_54.as_canonical_u64(); seed[53] = v_55.as_canonical_u64(); seed[54] = v_56.as_canonical_u64(); seed[55] = v_57.as_canonical_u64(); seed[56] = v_58.as_canonical_u64(); seed[57] = v_59.as_canonical_u64(); seed[58] = v_60.as_canonical_u64(); seed[59] = v_61.as_canonical_u64(); seed[60] = v_62.as_canonical_u64(); seed[61] = v_63.as_canonical_u64(); seed[62] = v_64.as_canonical_u64(); seed[63] = v_65.as_canonical_u64(); seed[64] = v_66.as_canonical_u64(); seed[65] = v_67.as_canonical_u64(); seed[66] = v_68.as_canonical_u64(); seed[67] = v_69.as_canonical_u64(); seed[68] = v_70.as_canonical_u64(); seed[69] = v_71.as_canonical_u64(); seed[70] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 249, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed[72] = v_74.as_canonical_u64(); seed[73] = v_75.as_canonical_u64(); seed[74] = v_76.as_canonical_u64(); seed[75] = v_77.as_canonical_u64(); seed[76] = v_78.as_canonical_u64(); seed[77] = v_79.as_canonical_u64(); seed[78] = v_80.as_canonical_u64(); seed[79] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(6, 2, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[80] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_117.as_canonical_u64(); seed[82] = v_118.as_canonical_u64(); seed[83] = v_119.as_canonical_u64(); seed[84] = v_120.as_canonical_u64(); seed[85] = v_121.as_canonical_u64(); seed[86] = v_122.as_canonical_u64(); seed[87] = v_123.as_canonical_u64(); seed[88] = v_124.as_canonical_u64(); seed[89] = v_125.as_canonical_u64(); seed[90] = v_126.as_canonical_u64(); seed[91] = v_127.as_canonical_u64(); seed[92] = v_128.as_canonical_u64(); seed[93] = v_129.as_canonical_u64(); seed[94] = v_130.as_canonical_u64(); seed[95] = v_131.as_canonical_u64(); seed[96] = v_132.as_canonical_u64(); seed[97] = v_133.as_canonical_u64(); seed[98] = v_134.as_canonical_u64(); seed[99] = v_135.as_canonical_u64(); seed[100] = v_136.as_canonical_u64(); seed[101] = v_137.as_canonical_u64(); seed[102] = v_138.as_canonical_u64(); seed[103] = v_139.as_canonical_u64(); seed[104] = v_140.as_canonical_u64(); seed[105] = v_141.as_canonical_u64(); seed[106] = v_142.as_canonical_u64(); seed[107] = v_143.as_canonical_u64(); seed[108] = v_144.as_canonical_u64(); seed[109] = v_145.as_canonical_u64(); seed[110] = v_146.as_canonical_u64(); seed[111] = v_147.as_canonical_u64(); seed[112] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 83, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed[113] = v_151.as_canonical_u64(); seed[114] = v_152.as_canonical_u64(); seed[115] = v_153.as_canonical_u64(); seed[116] = v_154.as_canonical_u64(); seed[117] = v_155.as_canonical_u64(); seed[118] = v_156.as_canonical_u64(); seed[119] = v_157.as_canonical_u64(); seed[120] = v_158.as_canonical_u64(); seed[121] = v_159.as_canonical_u64(); seed[122] = v_160.as_canonical_u64(); seed[123] = v_161.as_canonical_u64(); seed[124] = v_162.as_canonical_u64(); seed[125] = v_163.as_canonical_u64(); seed[126] = v_164.as_canonical_u64(); seed[127] = v_165.as_canonical_u64(); seed[128] = v_166.as_canonical_u64(); seed[129] = v_167.as_canonical_u64(); seed[130] = v_168.as_canonical_u64(); seed[131] = v_169.as_canonical_u64(); seed[132] = v_170.as_canonical_u64(); seed[133] = v_171.as_canonical_u64(); seed[134] = v_172.as_canonical_u64(); seed[135] = v_173.as_canonical_u64(); seed[136] = v_174.as_canonical_u64(); seed[137] = v_175.as_canonical_u64(); seed[138] = v_176.as_canonical_u64(); seed[139] = v_177.as_canonical_u64(); seed[140] = v_178.as_canonical_u64(); seed[141] = v_179.as_canonical_u64(); seed[142] = v_180.as_canonical_u64(); seed[143] = v_181.as_canonical_u64(); seed[144] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed[145] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed[146] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 11, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[147] = v_186.as_canonical_u64(); seed[148] = v_187.as_canonical_u64(); seed[149] = v_188.as_canonical_u64(); seed[150] = v_189.as_canonical_u64(); seed[151] = v_190.as_canonical_u64(); seed[152] = v_191.as_canonical_u64(); seed[153] = v_192.as_canonical_u64(); seed[154] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed[155] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, 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])?; seed[156] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = context.check_returned::<1>(51, 75, &[v_0, v_185, v_150, v_150, v_194, v_195, v_183])?; seed[157] = v_196.as_canonical_u64(); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 249, &[v_0])?; seed[71] = v_197.as_canonical_u64(); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 249, &[v_0])?; seed[72] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed[73] = v_200.as_canonical_u64(); seed[74] = v_201.as_canonical_u64(); seed[75] = v_202.as_canonical_u64(); seed[76] = v_203.as_canonical_u64(); seed[77] = v_204.as_canonical_u64(); seed[78] = v_205.as_canonical_u64(); seed[79] = v_206.as_canonical_u64(); seed[80] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = context.call::<1>(56, 2, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed[81] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed[82] = v_217.as_canonical_u64(); seed[83] = v_218.as_canonical_u64(); seed[84] = v_219.as_canonical_u64(); seed[85] = v_220.as_canonical_u64(); seed[86] = v_221.as_canonical_u64(); seed[87] = v_222.as_canonical_u64(); seed[88] = v_223.as_canonical_u64(); seed[89] = v_224.as_canonical_u64(); seed[90] = v_225.as_canonical_u64(); seed[91] = v_226.as_canonical_u64(); seed[92] = v_227.as_canonical_u64(); seed[93] = v_228.as_canonical_u64(); seed[94] = v_229.as_canonical_u64(); seed[95] = v_230.as_canonical_u64(); seed[96] = v_231.as_canonical_u64(); seed[97] = v_232.as_canonical_u64(); seed[98] = v_233.as_canonical_u64(); seed[99] = v_234.as_canonical_u64(); seed[100] = v_235.as_canonical_u64(); seed[101] = v_236.as_canonical_u64(); seed[102] = v_237.as_canonical_u64(); seed[103] = v_238.as_canonical_u64(); seed[104] = v_239.as_canonical_u64(); seed[105] = v_240.as_canonical_u64(); seed[106] = v_241.as_canonical_u64(); seed[107] = v_242.as_canonical_u64(); seed[108] = v_243.as_canonical_u64(); seed[109] = v_244.as_canonical_u64(); seed[110] = v_245.as_canonical_u64(); seed[111] = v_246.as_canonical_u64(); seed[112] = v_247.as_canonical_u64(); seed[113] = v_248.as_canonical_u64(); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 83, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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])?; seed[114] = v_266.as_canonical_u64(); seed[115] = v_267.as_canonical_u64(); seed[116] = v_268.as_canonical_u64(); seed[117] = v_269.as_canonical_u64(); seed[118] = v_270.as_canonical_u64(); seed[119] = v_271.as_canonical_u64(); seed[120] = v_272.as_canonical_u64(); seed[121] = v_273.as_canonical_u64(); seed[122] = v_274.as_canonical_u64(); seed[123] = v_275.as_canonical_u64(); seed[124] = v_276.as_canonical_u64(); seed[125] = v_277.as_canonical_u64(); seed[126] = v_278.as_canonical_u64(); seed[127] = v_279.as_canonical_u64(); seed[128] = v_280.as_canonical_u64(); seed[129] = v_281.as_canonical_u64(); seed[130] = v_282.as_canonical_u64(); seed[131] = v_283.as_canonical_u64(); seed[132] = v_284.as_canonical_u64(); seed[133] = v_285.as_canonical_u64(); seed[134] = v_286.as_canonical_u64(); seed[135] = v_287.as_canonical_u64(); seed[136] = v_288.as_canonical_u64(); seed[137] = v_289.as_canonical_u64(); seed[138] = v_290.as_canonical_u64(); seed[139] = v_291.as_canonical_u64(); seed[140] = v_292.as_canonical_u64(); seed[141] = v_293.as_canonical_u64(); seed[142] = v_294.as_canonical_u64(); seed[143] = v_295.as_canonical_u64(); seed[144] = v_296.as_canonical_u64(); seed[145] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed[146] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [v_2 + v_298]; let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed[147] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = context.check_returned::<1>(88, 75, &[v_0, v_299, v_265, v_300, v_3, v_301, v_5])?; seed[148] = v_302.as_canonical_u64(); Ok(()) }, } } + +fn write_79(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 64] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 65] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = [G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 66] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = [G::from_u64(seed[80])]; row[offsets.auxiliaries + 74] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; row[offsets.auxiliaries + 75] = v_83.as_canonical_u64(); let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = [G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 76] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_148.as_canonical_u64(); let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144])]; row[offsets.auxiliaries + 108] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = [G::from_u64(seed[145])]; row[offsets.auxiliaries + 140] = v_183.as_canonical_u64(); let [v_185]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 141] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = [G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 142] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = [G::from_u64(seed[155])]; row[offsets.auxiliaries + 150] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = [G::from_u64(seed[156])]; row[offsets.auxiliaries + 151] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = [G::from_u64(seed[157])]; row[offsets.auxiliaries + 152] = v_196.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 65] = (v_2 - G::from_u64(1023)).inverse().as_canonical_u64(); let [v_197]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 66] = v_197.as_canonical_u64(); let [v_199]: [G; 1] = [G::from_u64(seed[72])]; row[offsets.auxiliaries + 67] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 68] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = [G::from_u64(seed[81])]; row[offsets.auxiliaries + 76] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; row[offsets.auxiliaries + 77] = v_210.as_canonical_u64(); let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; row[offsets.auxiliaries + 78] = g_inverse_value(v_212).as_canonical_u64(); row[offsets.auxiliaries + 79] = v_213.as_canonical_u64(); let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = [G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113])]; row[offsets.auxiliaries + 80] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_223.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_237.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_248.as_canonical_u64(); let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = [G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 112] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_273.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_274.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_275.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_277.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_279.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_281.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_283.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_284.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_285.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_286.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_287.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_297.as_canonical_u64(); let [v_299]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 144] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = [G::from_u64(seed[147])]; row[offsets.auxiliaries + 145] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = [G::from_u64(seed[148])]; row[offsets.auxiliaries + 146] = v_302.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_79: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 96, 100, 8, 104, 108, 16, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 112, 116, 24, 32, 40, 48, 56, 64, 72, 80, 120, 124, 88], bytes: 272 }; + +fn pack_83(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_83_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn pack_83_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; let [v_470]: [G; 1] = [v_462 + v_465]; let [v_471]: [G; 1] = [v_464 + v_467]; let [v_472]: [G; 1] = [v_466 + v_469]; let [v_473]: [G; 1] = [v_468 + v_463]; let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; let [v_532]: [G; 1] = [v_524 + v_527]; let [v_533]: [G; 1] = [v_526 + v_529]; let [v_534]: [G; 1] = [v_528 + v_531]; let [v_535]: [G; 1] = [v_530 + v_525]; let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; let [v_594]: [G; 1] = [v_586 + v_589]; let [v_595]: [G; 1] = [v_588 + v_591]; let [v_596]: [G; 1] = [v_590 + v_593]; let [v_597]: [G; 1] = [v_592 + v_587]; let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; let [v_656]: [G; 1] = [v_648 + v_651]; let [v_657]: [G; 1] = [v_650 + v_653]; let [v_658]: [G; 1] = [v_652 + v_655]; let [v_659]: [G; 1] = [v_654 + v_649]; let [v_660]: [G; 1] = [v_0 + v_166]; let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.check_returned::<32>(436, 83, &[v_660, v_443, v_444, v_445, v_446, v_505, v_506, v_507, v_508, v_567, v_568, v_569, v_570, v_629, v_630, v_631, v_632, v_656, v_657, v_658, v_659, v_470, v_471, v_472, v_473, v_532, v_533, v_534, v_535, v_594, v_595, v_596, v_597, v_580, v_581, v_582, v_583, v_642, v_643, v_644, v_645, v_456, v_457, v_458, v_459, v_518, v_519, v_520, v_521, v_515, v_516, v_517, v_514, v_577, v_578, v_579, v_576, v_639, v_640, v_641, v_638, v_453, v_454, v_455, v_452, 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])?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn write_83(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_83: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_100(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.store(2, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[4] = v_4.as_canonical_u64(); Ok(()) }, _ => { let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 10] = context.call::<10>(3, 87, &[v_0])?; seed[3] = v_5.as_canonical_u64(); seed[4] = v_6.as_canonical_u64(); seed[5] = v_7.as_canonical_u64(); seed[6] = v_8.as_canonical_u64(); seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); let [v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 10] = context.call::<10>(4, 87, &[v_14])?; seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 10] = context.call::<10>(5, 88, &[v_24])?; seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44]: [G; 10] = context.call::<10>(6, 87, &[v_34])?; seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); let [v_45, v_46]: [G; 2] = context.call::<2>(7, 85, &[v_44])?; seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); let [v_47, v_48]: [G; 2] = context.call::<2>(8, 86, &[v_46])?; seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50, v_51]: [G; 2] = context.call::<2>(10, 93, &[v_48, v_47, v_49])?; seed[47] = v_50.as_canonical_u64(); seed[48] = v_51.as_canonical_u64(); let [v_52, v_53]: [G; 2] = context.call::<2>(11, 86, &[v_51])?; seed[49] = v_52.as_canonical_u64(); seed[50] = v_53.as_canonical_u64(); let [v_54, v_55]: [G; 2] = context.call::<2>(12, 94, &[v_53, v_52])?; seed[51] = v_54.as_canonical_u64(); seed[52] = v_55.as_canonical_u64(); let [v_56, v_57]: [G; 2] = context.call::<2>(13, 86, &[v_55])?; seed[53] = v_56.as_canonical_u64(); seed[54] = v_57.as_canonical_u64(); let [v_58, v_59]: [G; 2] = context.call::<2>(14, 96, &[v_57, v_56])?; seed[55] = v_58.as_canonical_u64(); seed[56] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(15, 97, &[v_56, v_49, v_45])?; seed[57] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; let [v_62]: [G; 1] = [v_60 + v_61]; let [v_63]: [G; 1] = [v_62 + v_62]; let [v_64]: [G; 1] = [v_52 + v_63]; let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = v_64.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_104]: [G; 1] = [G::from_u64(1)]; let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_63.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = v_45.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_176]: [G; 1] = [v_1 - v_104]; let [v_177, v_178, v_179]: [G; 3] = context.call::<3>(129, 100, &[v_59, v_176])?; seed[58] = v_177.as_canonical_u64(); seed[59] = v_178.as_canonical_u64(); seed[60] = v_179.as_canonical_u64(); let [v_180]: [G; 1] = context.store(130, &[v_49, v_50, v_47, v_54, v_35, v_58, v_45, v_5, v_15, v_63, v_177])?; seed[61] = v_180.as_canonical_u64(); let [v_181]: [G; 1] = context.store(131, &[v_49, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_178])?; seed[62] = v_181.as_canonical_u64(); let [v_182]: [G; 1] = context.store(132, &[v_49, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_181])?; seed[63] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(133, &[v_49, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_182])?; seed[64] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = context.store(134, &[v_49, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_183])?; seed[65] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = context.store(135, &[v_49, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_184])?; seed[66] = v_185.as_canonical_u64(); let [v_186]: [G; 1] = context.store(136, &[v_49, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_185])?; seed[67] = v_186.as_canonical_u64(); let [v_187]: [G; 1] = context.store(137, &[v_49, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_186])?; seed[68] = v_187.as_canonical_u64(); Ok(()) }, } } + +fn pack_100_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed.full(16, v_3); let [v_4]: [G; 1] = context.store(2, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed.full(24, v_4); Ok(()) }, _ => { let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 10] = context.call::<10>(3, 87, &[v_0])?; seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(276, v_8); seed.u8(277, v_9); seed.u8(278, v_10); seed.u8(279, v_11); seed.u8(280, v_12); seed.u8(281, v_13); seed.u32(180, v_14); let [v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 10] = context.call::<10>(4, 87, &[v_14])?; seed.full(40, v_15); seed.full(48, v_16); seed.full(56, v_17); seed.u8(282, v_18); seed.u8(283, v_19); seed.u8(284, v_20); seed.u8(285, v_21); seed.u8(286, v_22); seed.u8(287, v_23); seed.u32(184, v_24); let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 10] = context.call::<10>(5, 88, &[v_24])?; seed.full(64, v_25); seed.full(72, v_26); seed.full(80, v_27); seed.full(88, v_28); seed.full(96, v_29); seed.u8(288, v_30); seed.u8(289, v_31); seed.u8(290, v_32); seed.u8(291, v_33); seed.u32(188, v_34); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44]: [G; 10] = context.call::<10>(6, 87, &[v_34])?; seed.full(104, v_35); seed.full(112, v_36); seed.full(120, v_37); seed.u8(292, v_38); seed.u8(293, v_39); seed.u8(294, v_40); seed.u8(295, v_41); seed.u8(296, v_42); seed.u8(297, v_43); seed.u32(192, v_44); let [v_45, v_46]: [G; 2] = context.call::<2>(7, 85, &[v_44])?; seed.full(128, v_45); seed.u32(196, v_46); let [v_47, v_48]: [G; 2] = context.call::<2>(8, 86, &[v_46])?; seed.full(136, v_47); seed.u32(200, v_48); let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50, v_51]: [G; 2] = context.call::<2>(10, 93, &[v_48, v_47, v_49])?; seed.u32(204, v_50); seed.u32(208, v_51); let [v_52, v_53]: [G; 2] = context.call::<2>(11, 86, &[v_51])?; seed.full(144, v_52); seed.u32(212, v_53); let [v_54, v_55]: [G; 2] = context.call::<2>(12, 94, &[v_53, v_52])?; seed.u32(216, v_54); seed.u32(220, v_55); let [v_56, v_57]: [G; 2] = context.call::<2>(13, 86, &[v_55])?; seed.full(152, v_56); seed.u32(224, v_57); let [v_58, v_59]: [G; 2] = context.call::<2>(14, 96, &[v_57, v_56])?; seed.u32(228, v_58); seed.u32(232, v_59); let [v_60]: [G; 1] = context.call::<1>(15, 97, &[v_56, v_49, v_45])?; seed.full(160, v_60); let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; let [v_62]: [G; 1] = [v_60 + v_61]; let [v_63]: [G; 1] = [v_62 + v_62]; let [v_64]: [G; 1] = [v_52 + v_63]; let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = v_64.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_104]: [G; 1] = [G::from_u64(1)]; let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_63.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = v_45.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_176]: [G; 1] = [v_1 - v_104]; let [v_177, v_178, v_179]: [G; 3] = context.call::<3>(129, 100, &[v_59, v_176])?; seed.u32(236, v_177); seed.u32(240, v_178); seed.full(168, v_179); let [v_180]: [G; 1] = context.store(130, &[v_49, v_50, v_47, v_54, v_35, v_58, v_45, v_5, v_15, v_63, v_177])?; seed.u32(244, v_180); let [v_181]: [G; 1] = context.store(131, &[v_49, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_178])?; seed.u32(248, v_181); let [v_182]: [G; 1] = context.store(132, &[v_49, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_181])?; seed.u32(252, v_182); let [v_183]: [G; 1] = context.store(133, &[v_49, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_182])?; seed.u32(256, v_183); let [v_184]: [G; 1] = context.store(134, &[v_49, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_183])?; seed.u32(260, v_184); let [v_185]: [G; 1] = context.store(135, &[v_49, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_184])?; seed.u32(264, v_185); let [v_186]: [G; 1] = context.store(136, &[v_49, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_185])?; seed.u32(268, v_186); let [v_187]: [G; 1] = context.store(137, &[v_49, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_186])?; seed.u32(272, v_187); Ok(()) }, } } + +fn pack_100_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.store(2, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[4] = v_4.as_canonical_u64(); Ok(()) }, _ => { let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 10] = context.call::<10>(3, 87, &[v_0])?; seed[3] = v_5.as_canonical_u64(); seed[4] = v_6.as_canonical_u64(); seed[5] = v_7.as_canonical_u64(); seed[6] = v_8.as_canonical_u64(); seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); let [v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 10] = context.call::<10>(4, 87, &[v_14])?; seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 10] = context.call::<10>(5, 88, &[v_24])?; seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44]: [G; 10] = context.call::<10>(6, 87, &[v_34])?; seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); let [v_45, v_46]: [G; 2] = context.call::<2>(7, 85, &[v_44])?; seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); let [v_47, v_48]: [G; 2] = context.call::<2>(8, 86, &[v_46])?; seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50, v_51]: [G; 2] = context.call::<2>(10, 93, &[v_48, v_47, v_49])?; seed[47] = v_50.as_canonical_u64(); seed[48] = v_51.as_canonical_u64(); let [v_52, v_53]: [G; 2] = context.call::<2>(11, 86, &[v_51])?; seed[49] = v_52.as_canonical_u64(); seed[50] = v_53.as_canonical_u64(); let [v_54, v_55]: [G; 2] = context.call::<2>(12, 94, &[v_53, v_52])?; seed[51] = v_54.as_canonical_u64(); seed[52] = v_55.as_canonical_u64(); let [v_56, v_57]: [G; 2] = context.call::<2>(13, 86, &[v_55])?; seed[53] = v_56.as_canonical_u64(); seed[54] = v_57.as_canonical_u64(); let [v_58, v_59]: [G; 2] = context.call::<2>(14, 96, &[v_57, v_56])?; seed[55] = v_58.as_canonical_u64(); seed[56] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(15, 97, &[v_56, v_49, v_45])?; seed[57] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; let [v_62]: [G; 1] = [v_60 + v_61]; let [v_63]: [G; 1] = [v_62 + v_62]; let [v_64]: [G; 1] = [v_52 + v_63]; let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = v_64.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_104]: [G; 1] = [G::from_u64(1)]; let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_63.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = v_45.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_176]: [G; 1] = [v_1 - v_104]; let [v_177, v_178, v_179]: [G; 3] = context.call::<3>(129, 100, &[v_59, v_176])?; seed[58] = v_177.as_canonical_u64(); seed[59] = v_178.as_canonical_u64(); seed[60] = v_179.as_canonical_u64(); let [v_180]: [G; 1] = context.store(130, &[v_49, v_50, v_47, v_54, v_35, v_58, v_45, v_5, v_15, v_63, v_177])?; seed[61] = v_180.as_canonical_u64(); let [v_181]: [G; 1] = context.store(131, &[v_49, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_178])?; seed[62] = v_181.as_canonical_u64(); let [v_182]: [G; 1] = context.store(132, &[v_49, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_181])?; seed[63] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(133, &[v_49, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_182])?; seed[64] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = context.store(134, &[v_49, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_183])?; seed[65] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = context.store(135, &[v_49, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_184])?; seed[66] = v_185.as_canonical_u64(); let [v_186]: [G; 1] = context.store(136, &[v_49, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_185])?; seed[67] = v_186.as_canonical_u64(); let [v_187]: [G; 1] = context.store(137, &[v_49, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_186])?; seed[68] = v_187.as_canonical_u64(); Ok(()) }, } } + +fn write_100(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); let [v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 10] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_24.as_canonical_u64(); let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 10] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 22] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_34.as_canonical_u64(); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44]: [G; 10] = [G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42])]; row[offsets.auxiliaries + 32] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_44.as_canonical_u64(); let [v_45, v_46]: [G; 2] = [G::from_u64(seed[43]), G::from_u64(seed[44])]; row[offsets.auxiliaries + 42] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_46.as_canonical_u64(); let [v_47, v_48]: [G; 2] = [G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 44] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_48.as_canonical_u64(); let [v_50, v_51]: [G; 2] = [G::from_u64(seed[47]), G::from_u64(seed[48])]; row[offsets.auxiliaries + 46] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_51.as_canonical_u64(); let [v_52, v_53]: [G; 2] = [G::from_u64(seed[49]), G::from_u64(seed[50])]; row[offsets.auxiliaries + 48] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_53.as_canonical_u64(); let [v_54, v_55]: [G; 2] = [G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 50] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_55.as_canonical_u64(); let [v_56, v_57]: [G; 2] = [G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 52] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_57.as_canonical_u64(); let [v_58, v_59]: [G; 2] = [G::from_u64(seed[55]), G::from_u64(seed[56])]; row[offsets.auxiliaries + 54] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 56] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; row[offsets.auxiliaries + 57] = g_inverse_value(v_60).as_canonical_u64(); row[offsets.auxiliaries + 58] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = [v_60 + v_61]; let [v_63]: [G; 1] = [v_62 + v_62]; let [v_64]: [G; 1] = [v_52 + v_63]; let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = v_64.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 59] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_72.as_canonical_u64(); let [v_94]: [G; 1] = [G::from_u64(1020)]; let [v_95]: [G; 1] = [v_72 - v_94]; let [v_96]: [G; 1] = [v_71 + v_95]; let [v_97]: [G; 1] = [v_70 + v_96]; let [v_98]: [G; 1] = [v_69 + v_97]; let [v_99]: [G; 1] = [G::from_bool(v_98.is_zero())]; row[offsets.auxiliaries + 67] = g_inverse_value(v_98).as_canonical_u64(); row[offsets.auxiliaries + 68] = v_99.as_canonical_u64(); let [v_100]: [G; 1] = [v_67 + v_68]; let [v_101]: [G; 1] = [v_66 + v_100]; let [v_102]: [G; 1] = [v_65 + v_101]; let [v_103]: [G; 1] = [G::from_bool(v_102.is_zero())]; row[offsets.auxiliaries + 69] = g_inverse_value(v_102).as_canonical_u64(); row[offsets.auxiliaries + 70] = v_103.as_canonical_u64(); let [v_104]: [G; 1] = [G::from_u64(1)]; let [v_105]: [G; 1] = [v_104 - v_103]; let [v_106]: [G; 1] = [v_99 * v_105]; row[offsets.auxiliaries + 71] = v_106.as_canonical_u64(); let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_63.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 72] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_115.as_canonical_u64(); let [v_130]: [G; 1] = [v_115 - v_94]; let [v_131]: [G; 1] = [v_114 + v_130]; let [v_132]: [G; 1] = [v_113 + v_131]; let [v_133]: [G; 1] = [v_112 + v_132]; let [v_134]: [G; 1] = [G::from_bool(v_133.is_zero())]; row[offsets.auxiliaries + 80] = g_inverse_value(v_133).as_canonical_u64(); row[offsets.auxiliaries + 81] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [v_110 + v_111]; let [v_136]: [G; 1] = [v_109 + v_135]; let [v_137]: [G; 1] = [v_108 + v_136]; let [v_138]: [G; 1] = [G::from_bool(v_137.is_zero())]; row[offsets.auxiliaries + 82] = g_inverse_value(v_137).as_canonical_u64(); row[offsets.auxiliaries + 83] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [v_104 - v_138]; let [v_140]: [G; 1] = [v_134 * v_139]; row[offsets.auxiliaries + 84] = v_140.as_canonical_u64(); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = v_45.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 85] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_149.as_canonical_u64(); let [v_164]: [G; 1] = [v_149 - v_94]; let [v_165]: [G; 1] = [v_148 + v_164]; let [v_166]: [G; 1] = [v_147 + v_165]; let [v_167]: [G; 1] = [v_146 + v_166]; let [v_168]: [G; 1] = [G::from_bool(v_167.is_zero())]; row[offsets.auxiliaries + 93] = g_inverse_value(v_167).as_canonical_u64(); row[offsets.auxiliaries + 94] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [v_144 + v_145]; let [v_170]: [G; 1] = [v_143 + v_169]; let [v_171]: [G; 1] = [v_142 + v_170]; let [v_172]: [G; 1] = [G::from_bool(v_171.is_zero())]; row[offsets.auxiliaries + 95] = g_inverse_value(v_171).as_canonical_u64(); row[offsets.auxiliaries + 96] = v_172.as_canonical_u64(); let [v_173]: [G; 1] = [v_104 - v_172]; let [v_174]: [G; 1] = [v_168 * v_173]; row[offsets.auxiliaries + 97] = v_174.as_canonical_u64(); let [v_177, v_178, v_179]: [G; 3] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 98] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_179.as_canonical_u64(); let [v_180]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 101] = v_180.as_canonical_u64(); let [v_181]: [G; 1] = [G::from_u64(seed[62])]; row[offsets.auxiliaries + 102] = v_181.as_canonical_u64(); let [v_182]: [G; 1] = [G::from_u64(seed[63])]; row[offsets.auxiliaries + 103] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = [G::from_u64(seed[64])]; row[offsets.auxiliaries + 104] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(seed[65])]; row[offsets.auxiliaries + 105] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = [G::from_u64(seed[66])]; row[offsets.auxiliaries + 106] = v_185.as_canonical_u64(); let [v_186]: [G; 1] = [G::from_u64(seed[67])]; row[offsets.auxiliaries + 107] = v_186.as_canonical_u64(); let [v_187]: [G; 1] = [G::from_u64(seed[68])]; row[offsets.auxiliaries + 108] = v_187.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_100: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 176, 8, 16, 24, 32, 276, 277, 278, 279, 280, 281, 180, 40, 48, 56, 282, 283, 284, 285, 286, 287, 184, 64, 72, 80, 88, 96, 288, 289, 290, 291, 188, 104, 112, 120, 292, 293, 294, 295, 296, 297, 192, 128, 196, 136, 200, 204, 208, 144, 212, 216, 220, 152, 224, 228, 232, 160, 236, 240, 168, 244, 248, 252, 256, 260, 264, 268, 272], bytes: 304 }; + +fn pack_114(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 113, &[v_0, v_1])?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(2, v_4)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed[58] = v_58.as_canonical_u64(); seed[59] = v_59.as_canonical_u64(); seed[60] = v_60.as_canonical_u64(); seed[61] = v_61.as_canonical_u64(); seed[62] = v_62.as_canonical_u64(); seed[63] = v_63.as_canonical_u64(); seed[64] = v_64.as_canonical_u64(); seed[65] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(21, 83, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed[66] = v_82.as_canonical_u64(); seed[67] = v_83.as_canonical_u64(); seed[68] = v_84.as_canonical_u64(); seed[69] = v_85.as_canonical_u64(); seed[70] = v_86.as_canonical_u64(); seed[71] = v_87.as_canonical_u64(); seed[72] = v_88.as_canonical_u64(); seed[73] = v_89.as_canonical_u64(); seed[74] = v_90.as_canonical_u64(); seed[75] = v_91.as_canonical_u64(); seed[76] = v_92.as_canonical_u64(); seed[77] = v_93.as_canonical_u64(); seed[78] = v_94.as_canonical_u64(); seed[79] = v_95.as_canonical_u64(); seed[80] = v_96.as_canonical_u64(); seed[81] = v_97.as_canonical_u64(); seed[82] = v_98.as_canonical_u64(); seed[83] = v_99.as_canonical_u64(); seed[84] = v_100.as_canonical_u64(); seed[85] = v_101.as_canonical_u64(); seed[86] = v_102.as_canonical_u64(); seed[87] = v_103.as_canonical_u64(); seed[88] = v_104.as_canonical_u64(); seed[89] = v_105.as_canonical_u64(); seed[90] = v_106.as_canonical_u64(); seed[91] = v_107.as_canonical_u64(); seed[92] = v_108.as_canonical_u64(); seed[93] = v_109.as_canonical_u64(); seed[94] = v_110.as_canonical_u64(); seed[95] = v_111.as_canonical_u64(); seed[96] = v_112.as_canonical_u64(); seed[97] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, 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])?; seed[98] = v_114.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 113, &[v_14, v_15])?; seed[18] = v_115.as_canonical_u64(); seed[19] = v_116.as_canonical_u64(); seed[20] = v_117.as_canonical_u64(); seed[21] = v_118.as_canonical_u64(); seed[22] = v_119.as_canonical_u64(); seed[23] = v_120.as_canonical_u64(); seed[24] = v_121.as_canonical_u64(); seed[25] = v_122.as_canonical_u64(); seed[26] = v_123.as_canonical_u64(); seed[27] = v_124.as_canonical_u64(); seed[28] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 113, &[v_123, v_124])?; seed[29] = v_126.as_canonical_u64(); seed[30] = v_127.as_canonical_u64(); seed[31] = v_128.as_canonical_u64(); seed[32] = v_129.as_canonical_u64(); seed[33] = v_130.as_canonical_u64(); seed[34] = v_131.as_canonical_u64(); seed[35] = v_132.as_canonical_u64(); seed[36] = v_133.as_canonical_u64(); seed[37] = v_134.as_canonical_u64(); seed[38] = v_135.as_canonical_u64(); seed[39] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 113, &[v_134, v_135])?; seed[40] = v_137.as_canonical_u64(); seed[41] = v_138.as_canonical_u64(); seed[42] = v_139.as_canonical_u64(); seed[43] = v_140.as_canonical_u64(); seed[44] = v_141.as_canonical_u64(); seed[45] = v_142.as_canonical_u64(); seed[46] = v_143.as_canonical_u64(); seed[47] = v_144.as_canonical_u64(); seed[48] = v_145.as_canonical_u64(); seed[49] = v_146.as_canonical_u64(); seed[50] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 113, &[v_145, v_146])?; seed[51] = v_148.as_canonical_u64(); seed[52] = v_149.as_canonical_u64(); seed[53] = v_150.as_canonical_u64(); seed[54] = v_151.as_canonical_u64(); seed[55] = v_152.as_canonical_u64(); seed[56] = v_153.as_canonical_u64(); seed[57] = v_154.as_canonical_u64(); seed[58] = v_155.as_canonical_u64(); seed[59] = v_156.as_canonical_u64(); seed[60] = v_157.as_canonical_u64(); seed[61] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 113, &[v_156, v_157])?; seed[62] = v_159.as_canonical_u64(); seed[63] = v_160.as_canonical_u64(); seed[64] = v_161.as_canonical_u64(); seed[65] = v_162.as_canonical_u64(); seed[66] = v_163.as_canonical_u64(); seed[67] = v_164.as_canonical_u64(); seed[68] = v_165.as_canonical_u64(); seed[69] = v_166.as_canonical_u64(); seed[70] = v_167.as_canonical_u64(); seed[71] = v_168.as_canonical_u64(); seed[72] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 113, &[v_167, v_168])?; seed[73] = v_170.as_canonical_u64(); seed[74] = v_171.as_canonical_u64(); seed[75] = v_172.as_canonical_u64(); seed[76] = v_173.as_canonical_u64(); seed[77] = v_174.as_canonical_u64(); seed[78] = v_175.as_canonical_u64(); seed[79] = v_176.as_canonical_u64(); seed[80] = v_177.as_canonical_u64(); seed[81] = v_178.as_canonical_u64(); seed[82] = v_179.as_canonical_u64(); seed[83] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 113, &[v_178, v_179])?; seed[84] = v_181.as_canonical_u64(); seed[85] = v_182.as_canonical_u64(); seed[86] = v_183.as_canonical_u64(); seed[87] = v_184.as_canonical_u64(); seed[88] = v_185.as_canonical_u64(); seed[89] = v_186.as_canonical_u64(); seed[90] = v_187.as_canonical_u64(); seed[91] = v_188.as_canonical_u64(); seed[92] = v_189.as_canonical_u64(); seed[93] = v_190.as_canonical_u64(); seed[94] = v_191.as_canonical_u64(); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed[95] = v_201.as_canonical_u64(); seed[96] = v_202.as_canonical_u64(); seed[97] = v_203.as_canonical_u64(); seed[98] = v_204.as_canonical_u64(); seed[99] = v_205.as_canonical_u64(); seed[100] = v_206.as_canonical_u64(); seed[101] = v_207.as_canonical_u64(); seed[102] = v_208.as_canonical_u64(); seed[103] = v_209.as_canonical_u64(); seed[104] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed[105] = v_211.as_canonical_u64(); seed[106] = v_212.as_canonical_u64(); seed[107] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed[108] = v_225.as_canonical_u64(); seed[109] = v_226.as_canonical_u64(); seed[110] = v_227.as_canonical_u64(); seed[111] = v_228.as_canonical_u64(); seed[112] = v_229.as_canonical_u64(); seed[113] = v_230.as_canonical_u64(); seed[114] = v_231.as_canonical_u64(); seed[115] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = context.call::<1>(52, 2, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed[116] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed[117] = v_241.as_canonical_u64(); seed[118] = v_242.as_canonical_u64(); seed[119] = v_243.as_canonical_u64(); seed[120] = v_244.as_canonical_u64(); seed[121] = v_245.as_canonical_u64(); seed[122] = v_246.as_canonical_u64(); seed[123] = v_247.as_canonical_u64(); seed[124] = v_248.as_canonical_u64(); seed[125] = v_249.as_canonical_u64(); seed[126] = v_250.as_canonical_u64(); seed[127] = v_251.as_canonical_u64(); seed[128] = v_252.as_canonical_u64(); seed[129] = v_253.as_canonical_u64(); seed[130] = v_254.as_canonical_u64(); seed[131] = v_255.as_canonical_u64(); seed[132] = v_256.as_canonical_u64(); seed[133] = v_257.as_canonical_u64(); seed[134] = v_258.as_canonical_u64(); seed[135] = v_259.as_canonical_u64(); seed[136] = v_260.as_canonical_u64(); seed[137] = v_261.as_canonical_u64(); seed[138] = v_262.as_canonical_u64(); seed[139] = v_263.as_canonical_u64(); seed[140] = v_264.as_canonical_u64(); seed[141] = v_265.as_canonical_u64(); seed[142] = v_266.as_canonical_u64(); seed[143] = v_267.as_canonical_u64(); seed[144] = v_268.as_canonical_u64(); seed[145] = v_269.as_canonical_u64(); seed[146] = v_270.as_canonical_u64(); seed[147] = v_271.as_canonical_u64(); seed[148] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 83, &[v_288, 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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed[149] = v_289.as_canonical_u64(); seed[150] = v_290.as_canonical_u64(); seed[151] = v_291.as_canonical_u64(); seed[152] = v_292.as_canonical_u64(); seed[153] = v_293.as_canonical_u64(); seed[154] = v_294.as_canonical_u64(); seed[155] = v_295.as_canonical_u64(); seed[156] = v_296.as_canonical_u64(); seed[157] = v_297.as_canonical_u64(); seed[158] = v_298.as_canonical_u64(); seed[159] = v_299.as_canonical_u64(); seed[160] = v_300.as_canonical_u64(); seed[161] = v_301.as_canonical_u64(); seed[162] = v_302.as_canonical_u64(); seed[163] = v_303.as_canonical_u64(); seed[164] = v_304.as_canonical_u64(); seed[165] = v_305.as_canonical_u64(); seed[166] = v_306.as_canonical_u64(); seed[167] = v_307.as_canonical_u64(); seed[168] = v_308.as_canonical_u64(); seed[169] = v_309.as_canonical_u64(); seed[170] = v_310.as_canonical_u64(); seed[171] = v_311.as_canonical_u64(); seed[172] = v_312.as_canonical_u64(); seed[173] = v_313.as_canonical_u64(); seed[174] = v_314.as_canonical_u64(); seed[175] = v_315.as_canonical_u64(); seed[176] = v_316.as_canonical_u64(); seed[177] = v_317.as_canonical_u64(); seed[178] = v_318.as_canonical_u64(); seed[179] = v_319.as_canonical_u64(); seed[180] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_322.as_canonical_u64(); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed[181] = v_355.as_canonical_u64(); seed[182] = v_356.as_canonical_u64(); seed[183] = v_357.as_canonical_u64(); seed[184] = v_358.as_canonical_u64(); seed[185] = v_359.as_canonical_u64(); seed[186] = v_360.as_canonical_u64(); seed[187] = v_361.as_canonical_u64(); seed[188] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 11, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed[189] = v_363.as_canonical_u64(); seed[190] = v_364.as_canonical_u64(); seed[191] = v_365.as_canonical_u64(); seed[192] = v_366.as_canonical_u64(); seed[193] = v_367.as_canonical_u64(); seed[194] = v_368.as_canonical_u64(); seed[195] = v_369.as_canonical_u64(); seed[196] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed[197] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed[198] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[199] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed[200] = v_374.as_canonical_u64(); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed[182] = v_378.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn pack_114_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 113, &[v_0, v_1])?; seed.u8(404, v_6); seed.u8(405, v_7); seed.u8(406, v_8); seed.u8(407, v_9); seed.u8(408, v_10); seed.u8(409, v_11); seed.u8(410, v_12); seed.u8(411, v_13); seed.u32(328, v_14); seed.u32(332, v_15); seed.u8(412, v_16); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed.full(24, v_17); seed.full(32, v_18); seed.full(40, v_19); seed.full(48, v_20); seed.full(56, v_21); seed.full(64, v_22); seed.full(72, v_23); seed.full(80, v_24); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(2, v_4)?; seed.u32(336, v_25); seed.u32(340, v_26); seed.u8(413, v_27); seed.u8(414, v_28); seed.u8(415, v_29); seed.u8(416, v_30); seed.u8(417, v_31); seed.u8(418, v_32); seed.u8(419, v_33); seed.u8(420, v_34); seed.u8(421, v_35); seed.u32(344, v_36); seed.u32(348, v_37); seed.u8(422, v_38); seed.u8(423, v_39); seed.u8(424, v_40); seed.u8(425, v_41); seed.u8(426, v_42); seed.u8(427, v_43); seed.u8(428, v_44); seed.u8(429, v_45); seed.u8(430, v_46); seed.u32(352, v_47); seed.u32(356, v_48); seed.u8(431, v_49); seed.u8(432, v_50); seed.u8(433, v_51); seed.u8(434, v_52); seed.u8(435, v_53); seed.u8(436, v_54); seed.u8(437, v_55); seed.u8(438, v_56); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed.u8(439, v_58); seed.u32(360, v_59); seed.u32(364, v_60); seed.u8(440, v_61); seed.u8(441, v_62); seed.u8(442, v_63); seed.u8(443, v_64); seed.u8(444, v_65); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(21, 83, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed.u8(445, v_82); seed.u8(446, v_83); seed.u8(447, v_84); seed.u8(448, v_85); seed.u32(368, v_86); seed.u32(372, v_87); seed.u8(449, v_88); seed.u8(450, v_89); seed.u8(451, v_90); seed.u8(452, v_91); seed.u8(453, v_92); seed.u8(454, v_93); seed.u8(455, v_94); seed.u8(456, v_95); seed.u8(457, v_96); seed.u32(376, v_97); seed.u32(380, v_98); seed.u8(458, v_99); seed.u8(459, v_100); seed.u8(460, v_101); seed.u8(461, v_102); seed.u8(462, v_103); seed.u8(463, v_104); seed.u8(464, v_105); seed.u8(465, v_106); seed.u8(466, v_107); seed.u32(384, v_108); seed.u32(388, v_109); seed.u8(467, v_110); seed.u8(468, v_111); seed.full(88, v_112); seed.full(96, v_113); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, 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])?; seed.full(104, v_114); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 113, &[v_14, v_15])?; seed.full(24, v_115); seed.full(32, v_116); seed.full(40, v_117); seed.full(48, v_118); seed.full(56, v_119); seed.full(64, v_120); seed.full(72, v_121); seed.full(80, v_122); seed.u32(336, v_123); seed.u32(340, v_124); seed.u8(413, v_125); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 113, &[v_123, v_124])?; seed.u8(414, v_126); seed.u8(415, v_127); seed.u8(416, v_128); seed.u8(417, v_129); seed.u8(418, v_130); seed.u8(419, v_131); seed.u8(420, v_132); seed.u8(421, v_133); seed.u32(344, v_134); seed.u32(348, v_135); seed.u8(422, v_136); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 113, &[v_134, v_135])?; seed.u8(423, v_137); seed.u8(424, v_138); seed.u8(425, v_139); seed.u8(426, v_140); seed.u8(427, v_141); seed.u8(428, v_142); seed.u8(429, v_143); seed.u8(430, v_144); seed.u32(352, v_145); seed.u32(356, v_146); seed.u8(431, v_147); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 113, &[v_145, v_146])?; seed.u8(432, v_148); seed.u8(433, v_149); seed.u8(434, v_150); seed.u8(435, v_151); seed.u8(436, v_152); seed.u8(437, v_153); seed.u8(438, v_154); seed.u8(439, v_155); seed.u32(360, v_156); seed.u32(364, v_157); seed.u8(440, v_158); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 113, &[v_156, v_157])?; seed.u8(441, v_159); seed.u8(442, v_160); seed.u8(443, v_161); seed.u8(444, v_162); seed.u8(445, v_163); seed.u8(446, v_164); seed.u8(447, v_165); seed.u8(448, v_166); seed.u32(368, v_167); seed.u32(372, v_168); seed.u8(449, v_169); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 113, &[v_167, v_168])?; seed.u8(450, v_170); seed.u8(451, v_171); seed.u8(452, v_172); seed.u8(453, v_173); seed.u8(454, v_174); seed.u8(455, v_175); seed.u8(456, v_176); seed.u8(457, v_177); seed.u32(376, v_178); seed.u32(380, v_179); seed.u8(458, v_180); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 113, &[v_178, v_179])?; seed.u8(459, v_181); seed.u8(460, v_182); seed.u8(461, v_183); seed.u8(462, v_184); seed.u8(463, v_185); seed.u8(464, v_186); seed.u8(465, v_187); seed.u8(466, v_188); seed.u32(384, v_189); seed.u32(388, v_190); seed.u8(467, v_191); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed.u8(468, v_201); seed.full(88, v_202); seed.full(96, v_203); seed.full(104, v_204); seed.full(112, v_205); seed.full(120, v_206); seed.full(128, v_207); seed.full(136, v_208); seed.full(144, v_209); seed.full(152, v_210); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed.u8(469, v_211); seed.full(160, v_212); seed.full(168, v_213); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed.u8(470, v_225); seed.u8(471, v_226); seed.u8(472, v_227); seed.u8(473, v_228); seed.u8(474, v_229); seed.u8(475, v_230); seed.u8(476, v_231); seed.u8(477, v_232); let [v_233]: [G; 1] = context.call::<1>(52, 2, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed.u8(478, v_233); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed.u8(479, v_241); seed.u8(480, v_242); seed.u8(481, v_243); seed.u8(482, v_244); seed.u8(483, v_245); seed.u8(484, v_246); seed.u8(485, v_247); seed.u8(486, v_248); seed.u8(487, v_249); seed.u8(488, v_250); seed.u8(489, v_251); seed.u8(490, v_252); seed.u8(491, v_253); seed.u8(492, v_254); seed.u8(493, v_255); seed.u8(494, v_256); seed.u8(495, v_257); seed.u8(496, v_258); seed.u8(497, v_259); seed.u8(498, v_260); seed.u8(499, v_261); seed.u8(500, v_262); seed.u8(501, v_263); seed.u8(502, v_264); seed.u8(503, v_265); seed.u8(504, v_266); seed.u8(505, v_267); seed.u8(506, v_268); seed.u8(507, v_269); seed.u8(508, v_270); seed.u8(509, v_271); seed.u8(510, v_272); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 83, &[v_288, 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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed.u8(511, v_289); seed.u8(512, v_290); seed.u8(513, v_291); seed.u8(514, v_292); seed.u8(515, v_293); seed.u8(516, v_294); seed.u8(517, v_295); seed.u8(518, v_296); seed.u8(519, v_297); seed.u8(520, v_298); seed.u8(521, v_299); seed.u8(522, v_300); seed.u8(523, v_301); seed.u8(524, v_302); seed.u8(525, v_303); seed.u8(526, v_304); seed.u8(527, v_305); seed.u8(528, v_306); seed.u8(529, v_307); seed.u8(530, v_308); seed.u8(531, v_309); seed.u8(532, v_310); seed.u8(533, v_311); seed.u8(534, v_312); seed.u8(535, v_313); seed.u8(536, v_314); seed.u8(537, v_315); seed.u8(538, v_316); seed.u8(539, v_317); seed.u8(540, v_318); seed.u8(541, v_319); seed.u8(542, v_320); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_322); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed.full(176, v_355); seed.full(184, v_356); seed.full(192, v_357); seed.full(200, v_358); seed.full(208, v_359); seed.full(216, v_360); seed.full(224, v_361); seed.full(232, v_362); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 11, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed.full(240, v_363); seed.full(248, v_364); seed.full(256, v_365); seed.full(264, v_366); seed.full(272, v_367); seed.full(280, v_368); seed.full(288, v_369); seed.full(296, v_370); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed.u32(392, v_371); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed.u32(396, v_372); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.u32(400, v_373); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed.full(304, v_374); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_377); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed.full(184, v_378); Ok(()) }, } }, } }, } } + +fn pack_114_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 113, &[v_0, v_1])?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = context.load::<32>(2, v_4)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed[58] = v_58.as_canonical_u64(); seed[59] = v_59.as_canonical_u64(); seed[60] = v_60.as_canonical_u64(); seed[61] = v_61.as_canonical_u64(); seed[62] = v_62.as_canonical_u64(); seed[63] = v_63.as_canonical_u64(); seed[64] = v_64.as_canonical_u64(); seed[65] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(21, 83, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed[66] = v_82.as_canonical_u64(); seed[67] = v_83.as_canonical_u64(); seed[68] = v_84.as_canonical_u64(); seed[69] = v_85.as_canonical_u64(); seed[70] = v_86.as_canonical_u64(); seed[71] = v_87.as_canonical_u64(); seed[72] = v_88.as_canonical_u64(); seed[73] = v_89.as_canonical_u64(); seed[74] = v_90.as_canonical_u64(); seed[75] = v_91.as_canonical_u64(); seed[76] = v_92.as_canonical_u64(); seed[77] = v_93.as_canonical_u64(); seed[78] = v_94.as_canonical_u64(); seed[79] = v_95.as_canonical_u64(); seed[80] = v_96.as_canonical_u64(); seed[81] = v_97.as_canonical_u64(); seed[82] = v_98.as_canonical_u64(); seed[83] = v_99.as_canonical_u64(); seed[84] = v_100.as_canonical_u64(); seed[85] = v_101.as_canonical_u64(); seed[86] = v_102.as_canonical_u64(); seed[87] = v_103.as_canonical_u64(); seed[88] = v_104.as_canonical_u64(); seed[89] = v_105.as_canonical_u64(); seed[90] = v_106.as_canonical_u64(); seed[91] = v_107.as_canonical_u64(); seed[92] = v_108.as_canonical_u64(); seed[93] = v_109.as_canonical_u64(); seed[94] = v_110.as_canonical_u64(); seed[95] = v_111.as_canonical_u64(); seed[96] = v_112.as_canonical_u64(); seed[97] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, 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])?; seed[98] = v_114.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 113, &[v_14, v_15])?; seed[18] = v_115.as_canonical_u64(); seed[19] = v_116.as_canonical_u64(); seed[20] = v_117.as_canonical_u64(); seed[21] = v_118.as_canonical_u64(); seed[22] = v_119.as_canonical_u64(); seed[23] = v_120.as_canonical_u64(); seed[24] = v_121.as_canonical_u64(); seed[25] = v_122.as_canonical_u64(); seed[26] = v_123.as_canonical_u64(); seed[27] = v_124.as_canonical_u64(); seed[28] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 113, &[v_123, v_124])?; seed[29] = v_126.as_canonical_u64(); seed[30] = v_127.as_canonical_u64(); seed[31] = v_128.as_canonical_u64(); seed[32] = v_129.as_canonical_u64(); seed[33] = v_130.as_canonical_u64(); seed[34] = v_131.as_canonical_u64(); seed[35] = v_132.as_canonical_u64(); seed[36] = v_133.as_canonical_u64(); seed[37] = v_134.as_canonical_u64(); seed[38] = v_135.as_canonical_u64(); seed[39] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 113, &[v_134, v_135])?; seed[40] = v_137.as_canonical_u64(); seed[41] = v_138.as_canonical_u64(); seed[42] = v_139.as_canonical_u64(); seed[43] = v_140.as_canonical_u64(); seed[44] = v_141.as_canonical_u64(); seed[45] = v_142.as_canonical_u64(); seed[46] = v_143.as_canonical_u64(); seed[47] = v_144.as_canonical_u64(); seed[48] = v_145.as_canonical_u64(); seed[49] = v_146.as_canonical_u64(); seed[50] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 113, &[v_145, v_146])?; seed[51] = v_148.as_canonical_u64(); seed[52] = v_149.as_canonical_u64(); seed[53] = v_150.as_canonical_u64(); seed[54] = v_151.as_canonical_u64(); seed[55] = v_152.as_canonical_u64(); seed[56] = v_153.as_canonical_u64(); seed[57] = v_154.as_canonical_u64(); seed[58] = v_155.as_canonical_u64(); seed[59] = v_156.as_canonical_u64(); seed[60] = v_157.as_canonical_u64(); seed[61] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 113, &[v_156, v_157])?; seed[62] = v_159.as_canonical_u64(); seed[63] = v_160.as_canonical_u64(); seed[64] = v_161.as_canonical_u64(); seed[65] = v_162.as_canonical_u64(); seed[66] = v_163.as_canonical_u64(); seed[67] = v_164.as_canonical_u64(); seed[68] = v_165.as_canonical_u64(); seed[69] = v_166.as_canonical_u64(); seed[70] = v_167.as_canonical_u64(); seed[71] = v_168.as_canonical_u64(); seed[72] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 113, &[v_167, v_168])?; seed[73] = v_170.as_canonical_u64(); seed[74] = v_171.as_canonical_u64(); seed[75] = v_172.as_canonical_u64(); seed[76] = v_173.as_canonical_u64(); seed[77] = v_174.as_canonical_u64(); seed[78] = v_175.as_canonical_u64(); seed[79] = v_176.as_canonical_u64(); seed[80] = v_177.as_canonical_u64(); seed[81] = v_178.as_canonical_u64(); seed[82] = v_179.as_canonical_u64(); seed[83] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 113, &[v_178, v_179])?; seed[84] = v_181.as_canonical_u64(); seed[85] = v_182.as_canonical_u64(); seed[86] = v_183.as_canonical_u64(); seed[87] = v_184.as_canonical_u64(); seed[88] = v_185.as_canonical_u64(); seed[89] = v_186.as_canonical_u64(); seed[90] = v_187.as_canonical_u64(); seed[91] = v_188.as_canonical_u64(); seed[92] = v_189.as_canonical_u64(); seed[93] = v_190.as_canonical_u64(); seed[94] = v_191.as_canonical_u64(); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed[95] = v_201.as_canonical_u64(); seed[96] = v_202.as_canonical_u64(); seed[97] = v_203.as_canonical_u64(); seed[98] = v_204.as_canonical_u64(); seed[99] = v_205.as_canonical_u64(); seed[100] = v_206.as_canonical_u64(); seed[101] = v_207.as_canonical_u64(); seed[102] = v_208.as_canonical_u64(); seed[103] = v_209.as_canonical_u64(); seed[104] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed[105] = v_211.as_canonical_u64(); seed[106] = v_212.as_canonical_u64(); seed[107] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed[108] = v_225.as_canonical_u64(); seed[109] = v_226.as_canonical_u64(); seed[110] = v_227.as_canonical_u64(); seed[111] = v_228.as_canonical_u64(); seed[112] = v_229.as_canonical_u64(); seed[113] = v_230.as_canonical_u64(); seed[114] = v_231.as_canonical_u64(); seed[115] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = context.call::<1>(52, 2, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed[116] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed[117] = v_241.as_canonical_u64(); seed[118] = v_242.as_canonical_u64(); seed[119] = v_243.as_canonical_u64(); seed[120] = v_244.as_canonical_u64(); seed[121] = v_245.as_canonical_u64(); seed[122] = v_246.as_canonical_u64(); seed[123] = v_247.as_canonical_u64(); seed[124] = v_248.as_canonical_u64(); seed[125] = v_249.as_canonical_u64(); seed[126] = v_250.as_canonical_u64(); seed[127] = v_251.as_canonical_u64(); seed[128] = v_252.as_canonical_u64(); seed[129] = v_253.as_canonical_u64(); seed[130] = v_254.as_canonical_u64(); seed[131] = v_255.as_canonical_u64(); seed[132] = v_256.as_canonical_u64(); seed[133] = v_257.as_canonical_u64(); seed[134] = v_258.as_canonical_u64(); seed[135] = v_259.as_canonical_u64(); seed[136] = v_260.as_canonical_u64(); seed[137] = v_261.as_canonical_u64(); seed[138] = v_262.as_canonical_u64(); seed[139] = v_263.as_canonical_u64(); seed[140] = v_264.as_canonical_u64(); seed[141] = v_265.as_canonical_u64(); seed[142] = v_266.as_canonical_u64(); seed[143] = v_267.as_canonical_u64(); seed[144] = v_268.as_canonical_u64(); seed[145] = v_269.as_canonical_u64(); seed[146] = v_270.as_canonical_u64(); seed[147] = v_271.as_canonical_u64(); seed[148] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 83, &[v_288, 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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed[149] = v_289.as_canonical_u64(); seed[150] = v_290.as_canonical_u64(); seed[151] = v_291.as_canonical_u64(); seed[152] = v_292.as_canonical_u64(); seed[153] = v_293.as_canonical_u64(); seed[154] = v_294.as_canonical_u64(); seed[155] = v_295.as_canonical_u64(); seed[156] = v_296.as_canonical_u64(); seed[157] = v_297.as_canonical_u64(); seed[158] = v_298.as_canonical_u64(); seed[159] = v_299.as_canonical_u64(); seed[160] = v_300.as_canonical_u64(); seed[161] = v_301.as_canonical_u64(); seed[162] = v_302.as_canonical_u64(); seed[163] = v_303.as_canonical_u64(); seed[164] = v_304.as_canonical_u64(); seed[165] = v_305.as_canonical_u64(); seed[166] = v_306.as_canonical_u64(); seed[167] = v_307.as_canonical_u64(); seed[168] = v_308.as_canonical_u64(); seed[169] = v_309.as_canonical_u64(); seed[170] = v_310.as_canonical_u64(); seed[171] = v_311.as_canonical_u64(); seed[172] = v_312.as_canonical_u64(); seed[173] = v_313.as_canonical_u64(); seed[174] = v_314.as_canonical_u64(); seed[175] = v_315.as_canonical_u64(); seed[176] = v_316.as_canonical_u64(); seed[177] = v_317.as_canonical_u64(); seed[178] = v_318.as_canonical_u64(); seed[179] = v_319.as_canonical_u64(); seed[180] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_322.as_canonical_u64(); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed[181] = v_355.as_canonical_u64(); seed[182] = v_356.as_canonical_u64(); seed[183] = v_357.as_canonical_u64(); seed[184] = v_358.as_canonical_u64(); seed[185] = v_359.as_canonical_u64(); seed[186] = v_360.as_canonical_u64(); seed[187] = v_361.as_canonical_u64(); seed[188] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 11, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed[189] = v_363.as_canonical_u64(); seed[190] = v_364.as_canonical_u64(); seed[191] = v_365.as_canonical_u64(); seed[192] = v_366.as_canonical_u64(); seed[193] = v_367.as_canonical_u64(); seed[194] = v_368.as_canonical_u64(); seed[195] = v_369.as_canonical_u64(); seed[196] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed[197] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed[198] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[199] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = context.check_returned::<1>(117, 114, &[v_189, v_190, v_354, v_371, v_372, v_373])?; seed[200] = v_374.as_canonical_u64(); Ok(()) }, _ => { let [v_375]: [G; 1] = [G::from_u64(1)]; let [v_376]: [G; 1] = [v_2 + v_375]; let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = context.check_returned::<1>(121, 114, &[v_189, v_190, v_376, v_3, v_377, v_5])?; seed[182] = v_378.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn write_114(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_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]: [G; 32] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57])]; row[offsets.auxiliaries + 20] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_56.as_canonical_u64(); let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65])]; row[offsets.auxiliaries + 52] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_65.as_canonical_u64(); let [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]: [G; 32] = [G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 60] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = [G::from_u64(seed[98])]; row[offsets.auxiliaries + 92] = v_114.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 20] = (v_24 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_23 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_22 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_21 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_20 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_19 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_18 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_17 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 12] = (v_16 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 13] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39])]; row[offsets.auxiliaries + 24] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = [G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50])]; row[offsets.auxiliaries + 35] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = [G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 46] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 57] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83])]; row[offsets.auxiliaries + 68] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = [G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 79] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_191.as_canonical_u64(); let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104])]; row[offsets.auxiliaries + 90] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = [G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107])]; row[offsets.auxiliaries + 100] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); break 'yield_0 [v_214]; }, _ => { row[offsets.auxiliaries + 103] = (v_211 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_215]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); break 'yield_0 [v_215]; }, } }, _ => { row[offsets.auxiliaries + 100] = (v_201 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_216]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); break 'yield_0 [v_216]; }, } }; row[offsets.auxiliaries + 104] = v_217.as_canonical_u64(); let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; row[offsets.auxiliaries + 105] = g_inverse_value(v_219).as_canonical_u64(); row[offsets.auxiliaries + 106] = v_220.as_canonical_u64(); let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; row[offsets.auxiliaries + 107] = g_inverse_value(v_2).as_canonical_u64(); row[offsets.auxiliaries + 108] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_217 * v_220]; row[offsets.auxiliaries + 109] = v_222.as_canonical_u64(); let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = [G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 110] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [G::from_u64(seed[116])]; row[offsets.auxiliaries + 118] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; row[offsets.auxiliaries + 119] = v_234.as_canonical_u64(); let [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, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = [G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 120] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_255.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_256.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_260.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_261.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_262.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_263.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_264.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_265.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_272.as_canonical_u64(); let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163]), G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166]), G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169]), G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172]), G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175]), G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178]), G::from_u64(seed[179]), G::from_u64(seed[180])]; row[offsets.auxiliaries + 152] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 154] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 157] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_297.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_298.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_299.as_canonical_u64(); row[offsets.auxiliaries + 163] = v_300.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_304.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_305.as_canonical_u64(); row[offsets.auxiliaries + 169] = v_306.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_308.as_canonical_u64(); row[offsets.auxiliaries + 172] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_310.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_312.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_314.as_canonical_u64(); row[offsets.auxiliaries + 178] = v_315.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_316.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_317.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_318.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_322]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 184] = v_322.as_canonical_u64(); row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 184] = (v_217 - G::from_u64(1)).inverse().as_canonical_u64(); match v_220.as_canonical_u64() { 1u64 => { let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = [G::from_u64(seed[181]), G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184]), G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187]), G::from_u64(seed[188])]; row[offsets.auxiliaries + 185] = v_355.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_356.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_357.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_358.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_359.as_canonical_u64(); row[offsets.auxiliaries + 190] = v_360.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_361.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = [G::from_u64(seed[189]), G::from_u64(seed[190]), G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193]), G::from_u64(seed[194]), G::from_u64(seed[195]), G::from_u64(seed[196])]; row[offsets.auxiliaries + 193] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 194] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 195] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 196] = v_366.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_367.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_368.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 200] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = [G::from_u64(seed[197])]; row[offsets.auxiliaries + 201] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = [G::from_u64(seed[198])]; row[offsets.auxiliaries + 202] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = [G::from_u64(seed[199])]; row[offsets.auxiliaries + 203] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = [G::from_u64(seed[200])]; row[offsets.auxiliaries + 204] = v_374.as_canonical_u64(); row[offsets.selectors + 13] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 185] = (v_220 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_377]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 186] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = [G::from_u64(seed[182])]; row[offsets.auxiliaries + 187] = v_378.as_canonical_u64(); row[offsets.selectors + 14] = G::ONE.as_canonical_u64(); }, } }, } }, } } + +static SCHEMA_114: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 312, 316, 8, 320, 324, 16, 404, 405, 406, 407, 408, 409, 410, 411, 328, 332, 412, 24, 32, 40, 48, 56, 64, 72, 80, 336, 340, 413, 414, 415, 416, 417, 418, 419, 420, 421, 344, 348, 422, 423, 424, 425, 426, 427, 428, 429, 430, 352, 356, 431, 432, 433, 434, 435, 436, 437, 438, 439, 360, 364, 440, 441, 442, 443, 444, 445, 446, 447, 448, 368, 372, 449, 450, 451, 452, 453, 454, 455, 456, 457, 376, 380, 458, 459, 460, 461, 462, 463, 464, 465, 466, 384, 388, 467, 468, 88, 96, 104, 112, 120, 128, 136, 144, 152, 469, 160, 168, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 392, 396, 400, 304], bytes: 544 }; + +fn pack_172(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(103)]; let [v_6]: [G; 1] = [G::from_u64(230)]; let [v_7]: [G; 1] = [G::from_u64(9)]; let [v_8]: [G; 1] = [G::from_u64(106)]; let [v_9]: [G; 1] = [G::from_u64(133)]; let [v_10]: [G; 1] = [G::from_u64(174)]; let [v_11]: [G; 1] = [G::from_u64(187)]; let [v_12]: [G; 1] = [G::from_u64(114)]; let [v_13]: [G; 1] = [G::from_u64(243)]; let [v_14]: [G; 1] = [G::from_u64(110)]; let [v_15]: [G; 1] = [G::from_u64(60)]; let [v_16]: [G; 1] = [G::from_u64(58)]; let [v_17]: [G; 1] = [G::from_u64(245)]; let [v_18]: [G; 1] = [G::from_u64(79)]; let [v_19]: [G; 1] = [G::from_u64(165)]; let [v_20]: [G; 1] = [G::from_u64(127)]; let [v_21]: [G; 1] = [G::from_u64(82)]; let [v_22]: [G; 1] = [G::from_u64(14)]; let [v_23]: [G; 1] = [G::from_u64(81)]; let [v_24]: [G; 1] = [G::from_u64(140)]; let [v_25]: [G; 1] = [G::from_u64(104)]; let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = [G::from_u64(155)]; let [v_28]: [G; 1] = [G::from_u64(171)]; let [v_29]: [G; 1] = [G::from_u64(217)]; let [v_30]: [G; 1] = [G::from_u64(131)]; let [v_31]: [G; 1] = [G::from_u64(31)]; let [v_32]: [G; 1] = [G::from_u64(25)]; let [v_33]: [G; 1] = [G::from_u64(205)]; let [v_34]: [G; 1] = [G::from_u64(224)]; let [v_35]: [G; 1] = [G::from_u64(91)]; let [v_36]: [G; 1] = [G::from_u64(1)]; let [v_37]: [G; 1] = context.store(33, &[v_36, v_36, v_36])?; seed[6] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(0)]; let [v_39]: [G; 1] = context.store(35, &[v_38, v_38, v_38, v_38, v_38, v_38, v_38, v_38])?; seed[7] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = context.store(36, &[v_5, v_6, v_7, v_8, v_9, v_10, v_5, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed[8] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = context.store(37, &[v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36])?; seed[9] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.call::<1>(38, 75, &[v_0, v_37, v_38, v_38, v_39, v_40, v_41])?; seed[10] = v_42.as_canonical_u64(); let [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]: [G; 32] = context.call::<32>(39, 74, &[v_42])?; seed[11] = v_43.as_canonical_u64(); seed[12] = v_44.as_canonical_u64(); seed[13] = v_45.as_canonical_u64(); seed[14] = v_46.as_canonical_u64(); seed[15] = v_47.as_canonical_u64(); seed[16] = v_48.as_canonical_u64(); seed[17] = v_49.as_canonical_u64(); seed[18] = v_50.as_canonical_u64(); seed[19] = v_51.as_canonical_u64(); seed[20] = v_52.as_canonical_u64(); seed[21] = v_53.as_canonical_u64(); seed[22] = v_54.as_canonical_u64(); seed[23] = v_55.as_canonical_u64(); seed[24] = v_56.as_canonical_u64(); seed[25] = v_57.as_canonical_u64(); seed[26] = v_58.as_canonical_u64(); seed[27] = v_59.as_canonical_u64(); seed[28] = v_60.as_canonical_u64(); seed[29] = v_61.as_canonical_u64(); seed[30] = v_62.as_canonical_u64(); seed[31] = v_63.as_canonical_u64(); seed[32] = v_64.as_canonical_u64(); seed[33] = v_65.as_canonical_u64(); seed[34] = v_66.as_canonical_u64(); seed[35] = v_67.as_canonical_u64(); seed[36] = v_68.as_canonical_u64(); seed[37] = v_69.as_canonical_u64(); seed[38] = v_70.as_canonical_u64(); seed[39] = v_71.as_canonical_u64(); seed[40] = v_72.as_canonical_u64(); seed[41] = v_73.as_canonical_u64(); seed[42] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(40, 105, &[v_71, v_72, v_73, v_74, v_37])?; seed[43] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = context.call::<1>(41, 105, &[v_67, v_68, v_69, v_70, v_75])?; seed[44] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = context.call::<1>(42, 105, &[v_63, v_64, v_65, v_66, v_76])?; seed[45] = v_77.as_canonical_u64(); let [v_78]: [G; 1] = context.call::<1>(43, 105, &[v_59, v_60, v_61, v_62, v_77])?; seed[46] = v_78.as_canonical_u64(); let [v_79]: [G; 1] = context.call::<1>(44, 105, &[v_55, v_56, v_57, v_58, v_78])?; seed[47] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = context.call::<1>(45, 105, &[v_51, v_52, v_53, v_54, v_79])?; seed[48] = v_80.as_canonical_u64(); let [v_81]: [G; 1] = context.call::<1>(46, 105, &[v_47, v_48, v_49, v_50, v_80])?; seed[49] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(47, 105, &[v_43, v_44, v_45, v_46, v_81])?; seed[50] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = context.call::<1>(48, 126, &[v_82, v_37])?; seed[51] = v_83.as_canonical_u64(); let [v_84, v_85, v_86]: [G; 3] = context.load::<3>(49, v_83)?; seed[52] = v_84.as_canonical_u64(); seed[53] = v_85.as_canonical_u64(); seed[54] = v_86.as_canonical_u64(); match v_84.as_canonical_u64() { 0u64 => { let [v_87, v_88, v_89]: [G; 3] = context.load::<3>(50, v_86)?; seed[55] = v_87.as_canonical_u64(); seed[56] = v_88.as_canonical_u64(); seed[57] = v_89.as_canonical_u64(); match v_87.as_canonical_u64() { 0u64 => { let [v_90, v_91, v_92]: [G; 3] = context.load::<3>(51, v_89)?; seed[58] = v_90.as_canonical_u64(); seed[59] = v_91.as_canonical_u64(); seed[60] = v_92.as_canonical_u64(); match v_90.as_canonical_u64() { 0u64 => { let [v_93, v_94, v_95]: [G; 3] = context.load::<3>(52, v_92)?; seed[61] = v_93.as_canonical_u64(); seed[62] = v_94.as_canonical_u64(); seed[63] = v_95.as_canonical_u64(); match v_93.as_canonical_u64() { 0u64 => { let [v_96, v_97, v_98]: [G; 3] = context.load::<3>(53, v_95)?; seed[64] = v_96.as_canonical_u64(); seed[65] = v_97.as_canonical_u64(); seed[66] = v_98.as_canonical_u64(); match v_96.as_canonical_u64() { 0u64 => { let [v_99, v_100, v_101]: [G; 3] = context.load::<3>(54, v_98)?; seed[67] = v_99.as_canonical_u64(); seed[68] = v_100.as_canonical_u64(); seed[69] = v_101.as_canonical_u64(); match v_99.as_canonical_u64() { 0u64 => { let [v_102, v_103, v_104]: [G; 3] = context.load::<3>(55, v_101)?; seed[70] = v_102.as_canonical_u64(); seed[71] = v_103.as_canonical_u64(); seed[72] = v_104.as_canonical_u64(); match v_102.as_canonical_u64() { 0u64 => { let [v_105, v_106, v_107]: [G; 3] = context.load::<3>(56, v_104)?; seed[73] = v_105.as_canonical_u64(); seed[74] = v_106.as_canonical_u64(); seed[75] = v_107.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_102)) }, } }, _ => { Err(no_match(172, v_99)) }, } }, _ => { Err(no_match(172, v_96)) }, } }, _ => { Err(no_match(172, v_93)) }, } }, _ => { Err(no_match(172, v_90)) }, } }, _ => { Err(no_match(172, v_87)) }, } }, _ => { Err(no_match(172, v_84)) }, } }, 0u64 => { let [v_108, v_109, v_110]: [G; 3] = context.load::<3>(57, v_4)?; seed[6] = v_108.as_canonical_u64(); seed[7] = v_109.as_canonical_u64(); seed[8] = v_110.as_canonical_u64(); match v_108.as_canonical_u64() { 0u64 => { let [v_111, v_112, v_113]: [G; 3] = context.load::<3>(58, v_110)?; seed[9] = v_111.as_canonical_u64(); seed[10] = v_112.as_canonical_u64(); seed[11] = v_113.as_canonical_u64(); match v_111.as_canonical_u64() { 0u64 => { let [v_114, v_115, v_116]: [G; 3] = context.load::<3>(59, v_113)?; seed[12] = v_114.as_canonical_u64(); seed[13] = v_115.as_canonical_u64(); seed[14] = v_116.as_canonical_u64(); match v_114.as_canonical_u64() { 0u64 => { let [v_117, v_118, v_119]: [G; 3] = context.load::<3>(60, v_116)?; seed[15] = v_117.as_canonical_u64(); seed[16] = v_118.as_canonical_u64(); seed[17] = v_119.as_canonical_u64(); match v_117.as_canonical_u64() { 0u64 => { let [v_120, v_121, v_122]: [G; 3] = context.load::<3>(61, v_119)?; seed[18] = v_120.as_canonical_u64(); seed[19] = v_121.as_canonical_u64(); seed[20] = v_122.as_canonical_u64(); match v_120.as_canonical_u64() { 0u64 => { let [v_123, v_124, v_125]: [G; 3] = context.load::<3>(62, v_122)?; seed[21] = v_123.as_canonical_u64(); seed[22] = v_124.as_canonical_u64(); seed[23] = v_125.as_canonical_u64(); match v_123.as_canonical_u64() { 0u64 => { let [v_126, v_127, v_128]: [G; 3] = context.load::<3>(63, v_125)?; seed[24] = v_126.as_canonical_u64(); seed[25] = v_127.as_canonical_u64(); seed[26] = v_128.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_123)) }, } }, _ => { Err(no_match(172, v_120)) }, } }, _ => { Err(no_match(172, v_117)) }, } }, _ => { Err(no_match(172, v_114)) }, } }, _ => { Err(no_match(172, v_111)) }, } }, _ => { Err(no_match(172, v_108)) }, } }, _ => { Err(no_match(172, v_2)) }, } } + +fn pack_172_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(448, v_2); seed.full(8, v_3); seed.u32(368, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(103)]; let [v_6]: [G; 1] = [G::from_u64(230)]; let [v_7]: [G; 1] = [G::from_u64(9)]; let [v_8]: [G; 1] = [G::from_u64(106)]; let [v_9]: [G; 1] = [G::from_u64(133)]; let [v_10]: [G; 1] = [G::from_u64(174)]; let [v_11]: [G; 1] = [G::from_u64(187)]; let [v_12]: [G; 1] = [G::from_u64(114)]; let [v_13]: [G; 1] = [G::from_u64(243)]; let [v_14]: [G; 1] = [G::from_u64(110)]; let [v_15]: [G; 1] = [G::from_u64(60)]; let [v_16]: [G; 1] = [G::from_u64(58)]; let [v_17]: [G; 1] = [G::from_u64(245)]; let [v_18]: [G; 1] = [G::from_u64(79)]; let [v_19]: [G; 1] = [G::from_u64(165)]; let [v_20]: [G; 1] = [G::from_u64(127)]; let [v_21]: [G; 1] = [G::from_u64(82)]; let [v_22]: [G; 1] = [G::from_u64(14)]; let [v_23]: [G; 1] = [G::from_u64(81)]; let [v_24]: [G; 1] = [G::from_u64(140)]; let [v_25]: [G; 1] = [G::from_u64(104)]; let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = [G::from_u64(155)]; let [v_28]: [G; 1] = [G::from_u64(171)]; let [v_29]: [G; 1] = [G::from_u64(217)]; let [v_30]: [G; 1] = [G::from_u64(131)]; let [v_31]: [G; 1] = [G::from_u64(31)]; let [v_32]: [G; 1] = [G::from_u64(25)]; let [v_33]: [G; 1] = [G::from_u64(205)]; let [v_34]: [G; 1] = [G::from_u64(224)]; let [v_35]: [G; 1] = [G::from_u64(91)]; let [v_36]: [G; 1] = [G::from_u64(1)]; let [v_37]: [G; 1] = context.store(33, &[v_36, v_36, v_36])?; seed.u32(372, v_37); let [v_38]: [G; 1] = [G::from_u64(0)]; let [v_39]: [G; 1] = context.store(35, &[v_38, v_38, v_38, v_38, v_38, v_38, v_38, v_38])?; seed.full(16, v_39); let [v_40]: [G; 1] = context.store(36, &[v_5, v_6, v_7, v_8, v_9, v_10, v_5, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed.u32(376, v_40); let [v_41]: [G; 1] = context.store(37, &[v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36])?; seed.u32(380, v_41); let [v_42]: [G; 1] = context.call::<1>(38, 75, &[v_0, v_37, v_38, v_38, v_39, v_40, v_41])?; seed.full(24, v_42); let [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]: [G; 32] = context.call::<32>(39, 74, &[v_42])?; seed.full(32, v_43); seed.full(40, v_44); seed.full(48, v_45); seed.full(56, v_46); seed.full(64, v_47); seed.full(72, v_48); seed.full(80, v_49); seed.full(88, v_50); seed.full(96, v_51); seed.full(104, v_52); seed.full(112, v_53); seed.full(120, v_54); seed.full(128, v_55); seed.full(136, v_56); seed.full(144, v_57); seed.full(152, v_58); seed.full(160, v_59); seed.full(168, v_60); seed.full(176, v_61); seed.full(184, v_62); seed.full(192, v_63); seed.full(200, v_64); seed.full(208, v_65); seed.full(216, v_66); seed.full(224, v_67); seed.full(232, v_68); seed.full(240, v_69); seed.full(248, v_70); seed.full(256, v_71); seed.full(264, v_72); seed.full(272, v_73); seed.full(280, v_74); let [v_75]: [G; 1] = context.call::<1>(40, 105, &[v_71, v_72, v_73, v_74, v_37])?; seed.u32(384, v_75); let [v_76]: [G; 1] = context.call::<1>(41, 105, &[v_67, v_68, v_69, v_70, v_75])?; seed.u32(388, v_76); let [v_77]: [G; 1] = context.call::<1>(42, 105, &[v_63, v_64, v_65, v_66, v_76])?; seed.u32(392, v_77); let [v_78]: [G; 1] = context.call::<1>(43, 105, &[v_59, v_60, v_61, v_62, v_77])?; seed.u32(396, v_78); let [v_79]: [G; 1] = context.call::<1>(44, 105, &[v_55, v_56, v_57, v_58, v_78])?; seed.u32(400, v_79); let [v_80]: [G; 1] = context.call::<1>(45, 105, &[v_51, v_52, v_53, v_54, v_79])?; seed.u32(404, v_80); let [v_81]: [G; 1] = context.call::<1>(46, 105, &[v_47, v_48, v_49, v_50, v_80])?; seed.u32(408, v_81); let [v_82]: [G; 1] = context.call::<1>(47, 105, &[v_43, v_44, v_45, v_46, v_81])?; seed.u32(412, v_82); let [v_83]: [G; 1] = context.call::<1>(48, 126, &[v_82, v_37])?; seed.u32(416, v_83); let [v_84, v_85, v_86]: [G; 3] = context.load::<3>(49, v_83)?; seed.u8(449, v_84); seed.full(288, v_85); seed.u32(420, v_86); match v_84.as_canonical_u64() { 0u64 => { let [v_87, v_88, v_89]: [G; 3] = context.load::<3>(50, v_86)?; seed.u8(450, v_87); seed.full(296, v_88); seed.u32(424, v_89); match v_87.as_canonical_u64() { 0u64 => { let [v_90, v_91, v_92]: [G; 3] = context.load::<3>(51, v_89)?; seed.u8(451, v_90); seed.full(304, v_91); seed.u32(428, v_92); match v_90.as_canonical_u64() { 0u64 => { let [v_93, v_94, v_95]: [G; 3] = context.load::<3>(52, v_92)?; seed.u8(452, v_93); seed.full(312, v_94); seed.u32(432, v_95); match v_93.as_canonical_u64() { 0u64 => { let [v_96, v_97, v_98]: [G; 3] = context.load::<3>(53, v_95)?; seed.u8(453, v_96); seed.full(320, v_97); seed.u32(436, v_98); match v_96.as_canonical_u64() { 0u64 => { let [v_99, v_100, v_101]: [G; 3] = context.load::<3>(54, v_98)?; seed.u8(454, v_99); seed.full(328, v_100); seed.u32(440, v_101); match v_99.as_canonical_u64() { 0u64 => { let [v_102, v_103, v_104]: [G; 3] = context.load::<3>(55, v_101)?; seed.u8(455, v_102); seed.full(336, v_103); seed.u32(444, v_104); match v_102.as_canonical_u64() { 0u64 => { let [v_105, v_106, v_107]: [G; 3] = context.load::<3>(56, v_104)?; seed.u8(456, v_105); seed.full(344, v_106); seed.full(352, v_107); Ok(()) }, _ => { Err(no_match(172, v_102)) }, } }, _ => { Err(no_match(172, v_99)) }, } }, _ => { Err(no_match(172, v_96)) }, } }, _ => { Err(no_match(172, v_93)) }, } }, _ => { Err(no_match(172, v_90)) }, } }, _ => { Err(no_match(172, v_87)) }, } }, _ => { Err(no_match(172, v_84)) }, } }, 0u64 => { let [v_108, v_109, v_110]: [G; 3] = context.load::<3>(57, v_4)?; seed.u32(372, v_108); seed.full(16, v_109); seed.u32(376, v_110); match v_108.as_canonical_u64() { 0u64 => { let [v_111, v_112, v_113]: [G; 3] = context.load::<3>(58, v_110)?; seed.u32(380, v_111); seed.full(24, v_112); seed.full(32, v_113); match v_111.as_canonical_u64() { 0u64 => { let [v_114, v_115, v_116]: [G; 3] = context.load::<3>(59, v_113)?; seed.full(40, v_114); seed.full(48, v_115); seed.full(56, v_116); match v_114.as_canonical_u64() { 0u64 => { let [v_117, v_118, v_119]: [G; 3] = context.load::<3>(60, v_116)?; seed.full(64, v_117); seed.full(72, v_118); seed.full(80, v_119); match v_117.as_canonical_u64() { 0u64 => { let [v_120, v_121, v_122]: [G; 3] = context.load::<3>(61, v_119)?; seed.full(88, v_120); seed.full(96, v_121); seed.full(104, v_122); match v_120.as_canonical_u64() { 0u64 => { let [v_123, v_124, v_125]: [G; 3] = context.load::<3>(62, v_122)?; seed.full(112, v_123); seed.full(120, v_124); seed.full(128, v_125); match v_123.as_canonical_u64() { 0u64 => { let [v_126, v_127, v_128]: [G; 3] = context.load::<3>(63, v_125)?; seed.full(136, v_126); seed.full(144, v_127); seed.full(152, v_128); Ok(()) }, _ => { Err(no_match(172, v_123)) }, } }, _ => { Err(no_match(172, v_120)) }, } }, _ => { Err(no_match(172, v_117)) }, } }, _ => { Err(no_match(172, v_114)) }, } }, _ => { Err(no_match(172, v_111)) }, } }, _ => { Err(no_match(172, v_108)) }, } }, _ => { Err(no_match(172, v_2)) }, } } + +fn pack_172_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(103)]; let [v_6]: [G; 1] = [G::from_u64(230)]; let [v_7]: [G; 1] = [G::from_u64(9)]; let [v_8]: [G; 1] = [G::from_u64(106)]; let [v_9]: [G; 1] = [G::from_u64(133)]; let [v_10]: [G; 1] = [G::from_u64(174)]; let [v_11]: [G; 1] = [G::from_u64(187)]; let [v_12]: [G; 1] = [G::from_u64(114)]; let [v_13]: [G; 1] = [G::from_u64(243)]; let [v_14]: [G; 1] = [G::from_u64(110)]; let [v_15]: [G; 1] = [G::from_u64(60)]; let [v_16]: [G; 1] = [G::from_u64(58)]; let [v_17]: [G; 1] = [G::from_u64(245)]; let [v_18]: [G; 1] = [G::from_u64(79)]; let [v_19]: [G; 1] = [G::from_u64(165)]; let [v_20]: [G; 1] = [G::from_u64(127)]; let [v_21]: [G; 1] = [G::from_u64(82)]; let [v_22]: [G; 1] = [G::from_u64(14)]; let [v_23]: [G; 1] = [G::from_u64(81)]; let [v_24]: [G; 1] = [G::from_u64(140)]; let [v_25]: [G; 1] = [G::from_u64(104)]; let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = [G::from_u64(155)]; let [v_28]: [G; 1] = [G::from_u64(171)]; let [v_29]: [G; 1] = [G::from_u64(217)]; let [v_30]: [G; 1] = [G::from_u64(131)]; let [v_31]: [G; 1] = [G::from_u64(31)]; let [v_32]: [G; 1] = [G::from_u64(25)]; let [v_33]: [G; 1] = [G::from_u64(205)]; let [v_34]: [G; 1] = [G::from_u64(224)]; let [v_35]: [G; 1] = [G::from_u64(91)]; let [v_36]: [G; 1] = [G::from_u64(1)]; let [v_37]: [G; 1] = context.store(33, &[v_36, v_36, v_36])?; seed[6] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(0)]; let [v_39]: [G; 1] = context.store(35, &[v_38, v_38, v_38, v_38, v_38, v_38, v_38, v_38])?; seed[7] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = context.store(36, &[v_5, v_6, v_7, v_8, v_9, v_10, v_5, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed[8] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = context.store(37, &[v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36])?; seed[9] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.call::<1>(38, 75, &[v_0, v_37, v_38, v_38, v_39, v_40, v_41])?; seed[10] = v_42.as_canonical_u64(); let [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]: [G; 32] = context.call::<32>(39, 74, &[v_42])?; seed[11] = v_43.as_canonical_u64(); seed[12] = v_44.as_canonical_u64(); seed[13] = v_45.as_canonical_u64(); seed[14] = v_46.as_canonical_u64(); seed[15] = v_47.as_canonical_u64(); seed[16] = v_48.as_canonical_u64(); seed[17] = v_49.as_canonical_u64(); seed[18] = v_50.as_canonical_u64(); seed[19] = v_51.as_canonical_u64(); seed[20] = v_52.as_canonical_u64(); seed[21] = v_53.as_canonical_u64(); seed[22] = v_54.as_canonical_u64(); seed[23] = v_55.as_canonical_u64(); seed[24] = v_56.as_canonical_u64(); seed[25] = v_57.as_canonical_u64(); seed[26] = v_58.as_canonical_u64(); seed[27] = v_59.as_canonical_u64(); seed[28] = v_60.as_canonical_u64(); seed[29] = v_61.as_canonical_u64(); seed[30] = v_62.as_canonical_u64(); seed[31] = v_63.as_canonical_u64(); seed[32] = v_64.as_canonical_u64(); seed[33] = v_65.as_canonical_u64(); seed[34] = v_66.as_canonical_u64(); seed[35] = v_67.as_canonical_u64(); seed[36] = v_68.as_canonical_u64(); seed[37] = v_69.as_canonical_u64(); seed[38] = v_70.as_canonical_u64(); seed[39] = v_71.as_canonical_u64(); seed[40] = v_72.as_canonical_u64(); seed[41] = v_73.as_canonical_u64(); seed[42] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(40, 105, &[v_71, v_72, v_73, v_74, v_37])?; seed[43] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = context.call::<1>(41, 105, &[v_67, v_68, v_69, v_70, v_75])?; seed[44] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = context.call::<1>(42, 105, &[v_63, v_64, v_65, v_66, v_76])?; seed[45] = v_77.as_canonical_u64(); let [v_78]: [G; 1] = context.call::<1>(43, 105, &[v_59, v_60, v_61, v_62, v_77])?; seed[46] = v_78.as_canonical_u64(); let [v_79]: [G; 1] = context.call::<1>(44, 105, &[v_55, v_56, v_57, v_58, v_78])?; seed[47] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = context.call::<1>(45, 105, &[v_51, v_52, v_53, v_54, v_79])?; seed[48] = v_80.as_canonical_u64(); let [v_81]: [G; 1] = context.call::<1>(46, 105, &[v_47, v_48, v_49, v_50, v_80])?; seed[49] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(47, 105, &[v_43, v_44, v_45, v_46, v_81])?; seed[50] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = context.call::<1>(48, 126, &[v_82, v_37])?; seed[51] = v_83.as_canonical_u64(); let [v_84, v_85, v_86]: [G; 3] = context.load::<3>(49, v_83)?; seed[52] = v_84.as_canonical_u64(); seed[53] = v_85.as_canonical_u64(); seed[54] = v_86.as_canonical_u64(); match v_84.as_canonical_u64() { 0u64 => { let [v_87, v_88, v_89]: [G; 3] = context.load::<3>(50, v_86)?; seed[55] = v_87.as_canonical_u64(); seed[56] = v_88.as_canonical_u64(); seed[57] = v_89.as_canonical_u64(); match v_87.as_canonical_u64() { 0u64 => { let [v_90, v_91, v_92]: [G; 3] = context.load::<3>(51, v_89)?; seed[58] = v_90.as_canonical_u64(); seed[59] = v_91.as_canonical_u64(); seed[60] = v_92.as_canonical_u64(); match v_90.as_canonical_u64() { 0u64 => { let [v_93, v_94, v_95]: [G; 3] = context.load::<3>(52, v_92)?; seed[61] = v_93.as_canonical_u64(); seed[62] = v_94.as_canonical_u64(); seed[63] = v_95.as_canonical_u64(); match v_93.as_canonical_u64() { 0u64 => { let [v_96, v_97, v_98]: [G; 3] = context.load::<3>(53, v_95)?; seed[64] = v_96.as_canonical_u64(); seed[65] = v_97.as_canonical_u64(); seed[66] = v_98.as_canonical_u64(); match v_96.as_canonical_u64() { 0u64 => { let [v_99, v_100, v_101]: [G; 3] = context.load::<3>(54, v_98)?; seed[67] = v_99.as_canonical_u64(); seed[68] = v_100.as_canonical_u64(); seed[69] = v_101.as_canonical_u64(); match v_99.as_canonical_u64() { 0u64 => { let [v_102, v_103, v_104]: [G; 3] = context.load::<3>(55, v_101)?; seed[70] = v_102.as_canonical_u64(); seed[71] = v_103.as_canonical_u64(); seed[72] = v_104.as_canonical_u64(); match v_102.as_canonical_u64() { 0u64 => { let [v_105, v_106, v_107]: [G; 3] = context.load::<3>(56, v_104)?; seed[73] = v_105.as_canonical_u64(); seed[74] = v_106.as_canonical_u64(); seed[75] = v_107.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_102)) }, } }, _ => { Err(no_match(172, v_99)) }, } }, _ => { Err(no_match(172, v_96)) }, } }, _ => { Err(no_match(172, v_93)) }, } }, _ => { Err(no_match(172, v_90)) }, } }, _ => { Err(no_match(172, v_87)) }, } }, _ => { Err(no_match(172, v_84)) }, } }, 0u64 => { let [v_108, v_109, v_110]: [G; 3] = context.load::<3>(57, v_4)?; seed[6] = v_108.as_canonical_u64(); seed[7] = v_109.as_canonical_u64(); seed[8] = v_110.as_canonical_u64(); match v_108.as_canonical_u64() { 0u64 => { let [v_111, v_112, v_113]: [G; 3] = context.load::<3>(58, v_110)?; seed[9] = v_111.as_canonical_u64(); seed[10] = v_112.as_canonical_u64(); seed[11] = v_113.as_canonical_u64(); match v_111.as_canonical_u64() { 0u64 => { let [v_114, v_115, v_116]: [G; 3] = context.load::<3>(59, v_113)?; seed[12] = v_114.as_canonical_u64(); seed[13] = v_115.as_canonical_u64(); seed[14] = v_116.as_canonical_u64(); match v_114.as_canonical_u64() { 0u64 => { let [v_117, v_118, v_119]: [G; 3] = context.load::<3>(60, v_116)?; seed[15] = v_117.as_canonical_u64(); seed[16] = v_118.as_canonical_u64(); seed[17] = v_119.as_canonical_u64(); match v_117.as_canonical_u64() { 0u64 => { let [v_120, v_121, v_122]: [G; 3] = context.load::<3>(61, v_119)?; seed[18] = v_120.as_canonical_u64(); seed[19] = v_121.as_canonical_u64(); seed[20] = v_122.as_canonical_u64(); match v_120.as_canonical_u64() { 0u64 => { let [v_123, v_124, v_125]: [G; 3] = context.load::<3>(62, v_122)?; seed[21] = v_123.as_canonical_u64(); seed[22] = v_124.as_canonical_u64(); seed[23] = v_125.as_canonical_u64(); match v_123.as_canonical_u64() { 0u64 => { let [v_126, v_127, v_128]: [G; 3] = context.load::<3>(63, v_125)?; seed[24] = v_126.as_canonical_u64(); seed[25] = v_127.as_canonical_u64(); seed[26] = v_128.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_123)) }, } }, _ => { Err(no_match(172, v_120)) }, } }, _ => { Err(no_match(172, v_117)) }, } }, _ => { Err(no_match(172, v_114)) }, } }, _ => { Err(no_match(172, v_111)) }, } }, _ => { Err(no_match(172, v_108)) }, } }, _ => { Err(no_match(172, v_2)) }, } } + +fn write_172(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_37]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_37.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 6] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_42.as_canonical_u64(); let [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]: [G; 32] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42])]; row[offsets.auxiliaries + 9] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = [G::from_u64(seed[43])]; row[offsets.auxiliaries + 41] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 42] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(seed[45])]; row[offsets.auxiliaries + 43] = v_77.as_canonical_u64(); let [v_78]: [G; 1] = [G::from_u64(seed[46])]; row[offsets.auxiliaries + 44] = v_78.as_canonical_u64(); let [v_79]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 45] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 46] = v_80.as_canonical_u64(); let [v_81]: [G; 1] = [G::from_u64(seed[49])]; row[offsets.auxiliaries + 47] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 48] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 49] = v_83.as_canonical_u64(); let [v_84, v_85, v_86]: [G; 3] = [G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 50] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_86.as_canonical_u64(); match v_84.as_canonical_u64() { 0u64 => { let [v_87, v_88, v_89]: [G; 3] = [G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57])]; row[offsets.auxiliaries + 53] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_89.as_canonical_u64(); match v_87.as_canonical_u64() { 0u64 => { let [v_90, v_91, v_92]: [G; 3] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 56] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_92.as_canonical_u64(); match v_90.as_canonical_u64() { 0u64 => { let [v_93, v_94, v_95]: [G; 3] = [G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63])]; row[offsets.auxiliaries + 59] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_95.as_canonical_u64(); match v_93.as_canonical_u64() { 0u64 => { let [v_96, v_97, v_98]: [G; 3] = [G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66])]; row[offsets.auxiliaries + 62] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_98.as_canonical_u64(); match v_96.as_canonical_u64() { 0u64 => { let [v_99, v_100, v_101]: [G; 3] = [G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69])]; row[offsets.auxiliaries + 65] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_101.as_canonical_u64(); match v_99.as_canonical_u64() { 0u64 => { let [v_102, v_103, v_104]: [G; 3] = [G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 68] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_104.as_canonical_u64(); match v_102.as_canonical_u64() { 0u64 => { let [v_105, v_106, v_107]: [G; 3] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75])]; row[offsets.auxiliaries + 71] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_107.as_canonical_u64(); match v_105.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_105)) }, } }, _ => { Err(no_match(172, v_102)) }, } }, _ => { Err(no_match(172, v_99)) }, } }, _ => { Err(no_match(172, v_96)) }, } }, _ => { Err(no_match(172, v_93)) }, } }, _ => { Err(no_match(172, v_90)) }, } }, _ => { Err(no_match(172, v_87)) }, } }, _ => { Err(no_match(172, v_84)) }, } }, 0u64 => { let [v_108, v_109, v_110]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_110.as_canonical_u64(); match v_108.as_canonical_u64() { 0u64 => { let [v_111, v_112, v_113]: [G; 3] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 7] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_113.as_canonical_u64(); match v_111.as_canonical_u64() { 0u64 => { let [v_114, v_115, v_116]: [G; 3] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 10] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_116.as_canonical_u64(); match v_114.as_canonical_u64() { 0u64 => { let [v_117, v_118, v_119]: [G; 3] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 13] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_119.as_canonical_u64(); match v_117.as_canonical_u64() { 0u64 => { let [v_120, v_121, v_122]: [G; 3] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 16] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_122.as_canonical_u64(); match v_120.as_canonical_u64() { 0u64 => { let [v_123, v_124, v_125]: [G; 3] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23])]; row[offsets.auxiliaries + 19] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_125.as_canonical_u64(); match v_123.as_canonical_u64() { 0u64 => { let [v_126, v_127, v_128]: [G; 3] = [G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26])]; row[offsets.auxiliaries + 22] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_128.as_canonical_u64(); match v_126.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_126)) }, } }, _ => { Err(no_match(172, v_123)) }, } }, _ => { Err(no_match(172, v_120)) }, } }, _ => { Err(no_match(172, v_117)) }, } }, _ => { Err(no_match(172, v_114)) }, } }, _ => { Err(no_match(172, v_111)) }, } }, _ => { Err(no_match(172, v_108)) }, } }, _ => { Err(no_match(172, v_2)) }, } } + +static SCHEMA_172: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 360, 364, 448, 8, 368, 372, 16, 376, 380, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 384, 388, 392, 396, 400, 404, 408, 412, 416, 449, 288, 420, 450, 296, 424, 451, 304, 428, 452, 312, 432, 453, 320, 436, 454, 328, 440, 455, 336, 444, 456, 344, 352], bytes: 464 }; + +fn pack_200(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 11] = context.load::<11>(0, v_0)?; seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_21.as_canonical_u64() { _ => { let [v_32]: [G; 1] = context.call::<1>(2, 239, &[v_2, v_9])?; seed[32] = v_32.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = context.call::<1>(7, 198, &[v_24])?; seed[33] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = context.call::<2>(8, 250, &[v_3, v_9])?; seed[34] = v_37.as_canonical_u64(); seed[35] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.call::<1>(9, 239, &[v_4, v_9])?; seed[36] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.call::<1>(11, 239, &[v_39, v_40])?; seed[37] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.call::<1>(12, 239, &[v_39, v_35])?; seed[38] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.call::<1>(13, 239, &[v_5, v_9])?; seed[39] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(14, 239, &[v_43, v_40])?; seed[40] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = context.call::<1>(15, 239, &[v_43, v_35])?; seed[41] = v_45.as_canonical_u64(); let [v_46, v_47]: [G; 2] = context.call::<2>(16, 250, &[v_1, v_9])?; seed[42] = v_46.as_canonical_u64(); seed[43] = v_47.as_canonical_u64(); let [v_57, v_58]: [G; 2] = 'yield_0: { match v_46.as_canonical_u64() { 0u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; let [v_49]: [G; 1] = context.store(18, &[v_48, v_48, v_48, v_48])?; seed[44] = v_49.as_canonical_u64(); break 'yield_0 [v_49, v_49]; }, 1u64 => { match v_6.as_canonical_u64() { 0u64 => { let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.store(20, &[v_50, v_50, v_50, v_50])?; seed[44] = v_51.as_canonical_u64(); break 'yield_0 [v_51, v_51]; }, 1u64 => { let [v_52]: [G; 1] = context.call::<1>(21, 239, &[v_7, v_47])?; seed[44] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(23, 239, &[v_52, v_53])?; seed[45] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.call::<1>(25, 239, &[v_52, v_55])?; seed[46] = v_56.as_canonical_u64(); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(200, v_6)); }, } }, _ => { return Err(no_match(200, v_46)); }, } }; let [v_59]: [G; 1] = context.call::<1>(26, 242, &[v_41])?; seed[47] = v_59.as_canonical_u64(); let [v_62]: [G; 1] = [G::from_u64(1)]; let [v_63]: [G; 1] = context.call::<1>(31, 242, &[v_42])?; seed[48] = v_63.as_canonical_u64(); let [v_66]: [G; 1] = context.call::<1>(35, 242, &[v_44])?; seed[49] = v_66.as_canonical_u64(); let [v_69]: [G; 1] = context.call::<1>(39, 242, &[v_45])?; seed[50] = v_69.as_canonical_u64(); let [v_72]: [G; 1] = context.call::<1>(43, 242, &[v_57])?; seed[51] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(47, 242, &[v_58])?; seed[52] = v_75.as_canonical_u64(); let [v_78, v_79]: [G; 2] = context.call::<2>(51, 182, &[v_18, v_19, v_32])?; seed[53] = v_78.as_canonical_u64(); seed[54] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = [G::from_u64(0)]; let [v_81]: [G; 1] = [v_78 - v_62]; let [v_82]: [G; 1] = [v_79 - v_80]; let [v_83]: [G; 1] = context.call::<1>(55, 183, &[v_32])?; seed[55] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [g_inverse_value(v_83)]; let [v_89]: [G; 1] = [v_18 - v_62]; let [v_90]: [G; 1] = [v_19 - v_80]; let [v_91]: [G; 1] = [v_89 * v_89]; let [v_92]: [G; 1] = [G::from_u64(7)]; let [v_93]: [G; 1] = [v_90 * v_90]; let [v_94]: [G; 1] = [v_92 * v_93]; let [v_95]: [G; 1] = [v_91 - v_94]; let [v_96]: [G; 1] = [g_inverse_value(v_95)]; let [v_101]: [G; 1] = [v_89 * v_96]; let [v_102]: [G; 1] = [v_80 - v_90]; let [v_103]: [G; 1] = [v_102 * v_96]; let [v_104]: [G; 1] = [v_81 * v_101]; let [v_105]: [G; 1] = [v_82 * v_103]; let [v_106]: [G; 1] = [v_92 * v_105]; let [v_107]: [G; 1] = [v_104 + v_106]; let [v_108]: [G; 1] = [v_81 * v_103]; let [v_109]: [G; 1] = [v_82 * v_101]; let [v_110]: [G; 1] = [v_108 + v_109]; let [v_111]: [G; 1] = [v_18 - v_84]; let [v_112]: [G; 1] = [v_111 * v_111]; let [v_113]: [G; 1] = [v_112 - v_94]; let [v_114]: [G; 1] = [g_inverse_value(v_113)]; let [v_119]: [G; 1] = [v_111 * v_114]; let [v_120]: [G; 1] = [v_102 * v_114]; let [v_121]: [G; 1] = [v_81 * v_119]; let [v_122]: [G; 1] = [v_82 * v_120]; let [v_123]: [G; 1] = [v_92 * v_122]; let [v_124]: [G; 1] = [v_121 + v_123]; let [v_125]: [G; 1] = [v_81 * v_120]; let [v_126]: [G; 1] = [v_82 * v_119]; let [v_127]: [G; 1] = [v_125 + v_126]; let [v_140]: [G; 1] = context.store(120, &[v_62, v_62, v_62, v_62])?; seed[56] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = context.store(121, &[v_80, v_38, v_80, v_140])?; seed[57] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = context.store(122, &[v_80, v_37, v_80, v_141])?; seed[58] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = context.store(123, &[v_80, v_11, v_80, v_142])?; seed[59] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = context.store(124, &[v_80, v_10, v_80, v_143])?; seed[60] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = context.store(125, &[v_80, v_15, v_80, v_144])?; seed[61] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = context.store(126, &[v_80, v_14, v_80, v_145])?; seed[62] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = context.store(127, &[v_80, v_13, v_80, v_146])?; seed[63] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = context.store(128, &[v_80, v_12, v_80, v_147])?; seed[64] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = context.call::<1>(129, 185, &[v_32])?; seed[65] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = context.call::<1>(130, 183, &[v_32])?; seed[66] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_149 * v_150]; let [v_152]: [G; 1] = [g_inverse_value(v_151)]; let [v_157, v_158]: [G; 2] = context.call::<2>(139, 191, &[v_80, v_80, v_16, v_17, v_23, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed[67] = v_157.as_canonical_u64(); seed[68] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [v_37 - v_10]; let [v_160]: [G; 1] = [v_80 - v_80]; let [v_161]: [G; 1] = [v_159 * v_152]; let [v_162]: [G; 1] = [v_160 * v_80]; let [v_163]: [G; 1] = [v_92 * v_162]; let [v_164]: [G; 1] = [v_161 + v_163]; let [v_165]: [G; 1] = [v_159 * v_80]; let [v_166]: [G; 1] = [v_160 * v_152]; let [v_167]: [G; 1] = [v_165 + v_166]; let [v_168]: [G; 1] = [v_124 * v_164]; let [v_169]: [G; 1] = [v_127 * v_167]; let [v_170]: [G; 1] = [v_92 * v_169]; let [v_171]: [G; 1] = [v_168 + v_170]; let [v_172]: [G; 1] = [v_124 * v_167]; let [v_173]: [G; 1] = [v_127 * v_164]; let [v_174]: [G; 1] = [v_172 + v_173]; let [v_175]: [G; 1] = [v_38 - v_11]; let [v_176]: [G; 1] = [v_175 * v_152]; let [v_177]: [G; 1] = [v_176 + v_163]; let [v_178]: [G; 1] = [v_175 * v_80]; let [v_179]: [G; 1] = [v_178 + v_166]; let [v_180]: [G; 1] = [v_124 * v_177]; let [v_181]: [G; 1] = [v_127 * v_179]; let [v_182]: [G; 1] = [v_92 * v_181]; let [v_183]: [G; 1] = [v_180 + v_182]; let [v_184]: [G; 1] = [v_124 * v_179]; let [v_185]: [G; 1] = [v_127 * v_177]; let [v_186]: [G; 1] = [v_184 + v_185]; let [v_187, v_188, v_189, v_190]: [G; 4] = context.load::<4>(168, v_25)?; seed[69] = v_187.as_canonical_u64(); seed[70] = v_188.as_canonical_u64(); seed[71] = v_189.as_canonical_u64(); seed[72] = v_190.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_187.as_canonical_u64() { 1u64 => { let [v_191]: [G; 1] = [G::from_u64(0)]; let [v_192, v_193]: [G; 2] = context.call::<2>(170, 250, &[v_45, v_191])?; seed[73] = v_192.as_canonical_u64(); seed[74] = v_193.as_canonical_u64(); let [v_194, v_195]: [G; 2] = context.call::<2>(171, 250, &[v_44, v_191])?; seed[75] = v_194.as_canonical_u64(); seed[76] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = [v_192 - v_194]; let [v_197]: [G; 1] = [v_193 - v_195]; let [v_198]: [G; 1] = [v_196 + v_171]; let [v_199]: [G; 1] = [v_197 + v_174]; let [v_200, v_201]: [G; 2] = context.call::<2>(176, 187, &[v_157, v_158, v_16, v_17, v_198, v_199])?; seed[77] = v_200.as_canonical_u64(); seed[78] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [G::from_u64(1)]; let [v_203, v_204]: [G; 2] = context.call::<2>(178, 250, &[v_45, v_202])?; seed[79] = v_203.as_canonical_u64(); seed[80] = v_204.as_canonical_u64(); let [v_205, v_206]: [G; 2] = context.call::<2>(179, 250, &[v_44, v_202])?; seed[81] = v_205.as_canonical_u64(); seed[82] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [v_203 - v_205]; let [v_208]: [G; 1] = [v_204 - v_206]; let [v_209]: [G; 1] = [v_207 + v_183]; let [v_210]: [G; 1] = [v_208 + v_186]; let [v_211, v_212]: [G; 2] = context.call::<2>(184, 187, &[v_200, v_201, v_16, v_17, v_209, v_210])?; seed[83] = v_211.as_canonical_u64(); seed[84] = v_212.as_canonical_u64(); break 'yield_0 []; }, 0u64 => { let [v_213]: [G; 1] = [G::from_u64(0)]; let [v_214]: [G; 1] = context.call::<1>(186, 242, &[v_25])?; seed[73] = v_214.as_canonical_u64(); let [v_215]: [G; 1] = [G::from_u64(1)]; let [v_216, v_217]: [G; 2] = context.call::<2>(188, 194, &[v_157, v_158, v_16, v_17, v_25, v_213, v_214, v_213, v_26, v_26, v_215, v_213, v_213, v_213, v_213, v_213, v_213, v_213, v_171, v_174, v_183, v_186, v_12, v_80, v_13, v_80, v_14, v_80, v_15, v_80, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed[74] = v_216.as_canonical_u64(); seed[75] = v_217.as_canonical_u64(); break 'yield_0 []; }, _ => { return Err(no_match(200, v_187)); }, } }; let [v_220]: [G; 1] = context.call::<1>(189, 239, &[v_8, v_9])?; seed[85] = v_220.as_canonical_u64(); let [v_221]: [G; 1] = [G::from_u64(0)]; let [v_222]: [G; 1] = context.call::<1>(191, 239, &[v_220, v_221])?; seed[86] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = context.call::<1>(192, 189, &[v_222])?; seed[87] = v_223.as_canonical_u64(); let [v_224]: [G; 1] = context.call::<1>(193, 242, &[v_223])?; seed[88] = v_224.as_canonical_u64(); let [v_227]: [G; 1] = [G::from_u64(1)]; let [v_228, v_229]: [G; 2] = context.call::<2>(198, 182, &[v_18, v_19, v_32])?; seed[89] = v_228.as_canonical_u64(); seed[90] = v_229.as_canonical_u64(); let [v_230, v_231]: [G; 2] = context.call::<2>(199, 197, &[v_223, v_228, v_229, v_227, v_221])?; seed[91] = v_230.as_canonical_u64(); seed[92] = v_231.as_canonical_u64(); let [v_246]: [G; 1] = context.returned::<1>(215)?; seed[93] = v_246.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(200, v_20)) }, } } + +fn pack_200_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 11] = context.load::<11>(0, v_0)?; seed.u8(605, v_20); seed.u32(516, v_21); seed.full(152, v_22); seed.u32(520, v_23); seed.full(160, v_24); seed.u32(524, v_25); seed.full(168, v_26); seed.full(176, v_27); seed.full(184, v_28); seed.full(192, v_29); seed.u32(528, v_30); match v_20.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_21.as_canonical_u64() { _ => { let [v_32]: [G; 1] = context.call::<1>(2, 239, &[v_2, v_9])?; seed.u8(606, v_32); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = context.call::<1>(7, 198, &[v_24])?; seed.u8(607, v_36); let [v_37, v_38]: [G; 2] = context.call::<2>(8, 250, &[v_3, v_9])?; seed.full(200, v_37); seed.full(208, v_38); let [v_39]: [G; 1] = context.call::<1>(9, 239, &[v_4, v_9])?; seed.full(216, v_39); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.call::<1>(11, 239, &[v_39, v_40])?; seed.u32(532, v_41); let [v_42]: [G; 1] = context.call::<1>(12, 239, &[v_39, v_35])?; seed.u32(536, v_42); let [v_43]: [G; 1] = context.call::<1>(13, 239, &[v_5, v_9])?; seed.full(224, v_43); let [v_44]: [G; 1] = context.call::<1>(14, 239, &[v_43, v_40])?; seed.u32(540, v_44); let [v_45]: [G; 1] = context.call::<1>(15, 239, &[v_43, v_35])?; seed.u32(544, v_45); let [v_46, v_47]: [G; 2] = context.call::<2>(16, 250, &[v_1, v_9])?; seed.u8(608, v_46); seed.full(232, v_47); let [v_57, v_58]: [G; 2] = 'yield_0: { match v_46.as_canonical_u64() { 0u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; let [v_49]: [G; 1] = context.store(18, &[v_48, v_48, v_48, v_48])?; seed.full(240, v_49); break 'yield_0 [v_49, v_49]; }, 1u64 => { match v_6.as_canonical_u64() { 0u64 => { let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.store(20, &[v_50, v_50, v_50, v_50])?; seed.full(240, v_51); break 'yield_0 [v_51, v_51]; }, 1u64 => { let [v_52]: [G; 1] = context.call::<1>(21, 239, &[v_7, v_47])?; seed.full(240, v_52); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(23, 239, &[v_52, v_53])?; seed.u32(548, v_54); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.call::<1>(25, 239, &[v_52, v_55])?; seed.u32(552, v_56); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(200, v_6)); }, } }, _ => { return Err(no_match(200, v_46)); }, } }; let [v_59]: [G; 1] = context.call::<1>(26, 242, &[v_41])?; seed.full(248, v_59); let [v_62]: [G; 1] = [G::from_u64(1)]; let [v_63]: [G; 1] = context.call::<1>(31, 242, &[v_42])?; seed.full(256, v_63); let [v_66]: [G; 1] = context.call::<1>(35, 242, &[v_44])?; seed.full(264, v_66); let [v_69]: [G; 1] = context.call::<1>(39, 242, &[v_45])?; seed.full(272, v_69); let [v_72]: [G; 1] = context.call::<1>(43, 242, &[v_57])?; seed.full(280, v_72); let [v_75]: [G; 1] = context.call::<1>(47, 242, &[v_58])?; seed.full(288, v_75); let [v_78, v_79]: [G; 2] = context.call::<2>(51, 182, &[v_18, v_19, v_32])?; seed.full(296, v_78); seed.full(304, v_79); let [v_80]: [G; 1] = [G::from_u64(0)]; let [v_81]: [G; 1] = [v_78 - v_62]; let [v_82]: [G; 1] = [v_79 - v_80]; let [v_83]: [G; 1] = context.call::<1>(55, 183, &[v_32])?; seed.full(312, v_83); let [v_84]: [G; 1] = [g_inverse_value(v_83)]; let [v_89]: [G; 1] = [v_18 - v_62]; let [v_90]: [G; 1] = [v_19 - v_80]; let [v_91]: [G; 1] = [v_89 * v_89]; let [v_92]: [G; 1] = [G::from_u64(7)]; let [v_93]: [G; 1] = [v_90 * v_90]; let [v_94]: [G; 1] = [v_92 * v_93]; let [v_95]: [G; 1] = [v_91 - v_94]; let [v_96]: [G; 1] = [g_inverse_value(v_95)]; let [v_101]: [G; 1] = [v_89 * v_96]; let [v_102]: [G; 1] = [v_80 - v_90]; let [v_103]: [G; 1] = [v_102 * v_96]; let [v_104]: [G; 1] = [v_81 * v_101]; let [v_105]: [G; 1] = [v_82 * v_103]; let [v_106]: [G; 1] = [v_92 * v_105]; let [v_107]: [G; 1] = [v_104 + v_106]; let [v_108]: [G; 1] = [v_81 * v_103]; let [v_109]: [G; 1] = [v_82 * v_101]; let [v_110]: [G; 1] = [v_108 + v_109]; let [v_111]: [G; 1] = [v_18 - v_84]; let [v_112]: [G; 1] = [v_111 * v_111]; let [v_113]: [G; 1] = [v_112 - v_94]; let [v_114]: [G; 1] = [g_inverse_value(v_113)]; let [v_119]: [G; 1] = [v_111 * v_114]; let [v_120]: [G; 1] = [v_102 * v_114]; let [v_121]: [G; 1] = [v_81 * v_119]; let [v_122]: [G; 1] = [v_82 * v_120]; let [v_123]: [G; 1] = [v_92 * v_122]; let [v_124]: [G; 1] = [v_121 + v_123]; let [v_125]: [G; 1] = [v_81 * v_120]; let [v_126]: [G; 1] = [v_82 * v_119]; let [v_127]: [G; 1] = [v_125 + v_126]; let [v_140]: [G; 1] = context.store(120, &[v_62, v_62, v_62, v_62])?; seed.u32(556, v_140); let [v_141]: [G; 1] = context.store(121, &[v_80, v_38, v_80, v_140])?; seed.u32(560, v_141); let [v_142]: [G; 1] = context.store(122, &[v_80, v_37, v_80, v_141])?; seed.u32(564, v_142); let [v_143]: [G; 1] = context.store(123, &[v_80, v_11, v_80, v_142])?; seed.u32(568, v_143); let [v_144]: [G; 1] = context.store(124, &[v_80, v_10, v_80, v_143])?; seed.u32(572, v_144); let [v_145]: [G; 1] = context.store(125, &[v_80, v_15, v_80, v_144])?; seed.u32(576, v_145); let [v_146]: [G; 1] = context.store(126, &[v_80, v_14, v_80, v_145])?; seed.u32(580, v_146); let [v_147]: [G; 1] = context.store(127, &[v_80, v_13, v_80, v_146])?; seed.u32(584, v_147); let [v_148]: [G; 1] = context.store(128, &[v_80, v_12, v_80, v_147])?; seed.u32(588, v_148); let [v_149]: [G; 1] = context.call::<1>(129, 185, &[v_32])?; seed.full(320, v_149); let [v_150]: [G; 1] = context.call::<1>(130, 183, &[v_32])?; seed.full(328, v_150); let [v_151]: [G; 1] = [v_149 * v_150]; let [v_152]: [G; 1] = [g_inverse_value(v_151)]; let [v_157, v_158]: [G; 2] = context.call::<2>(139, 191, &[v_80, v_80, v_16, v_17, v_23, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed.full(336, v_157); seed.full(344, v_158); let [v_159]: [G; 1] = [v_37 - v_10]; let [v_160]: [G; 1] = [v_80 - v_80]; let [v_161]: [G; 1] = [v_159 * v_152]; let [v_162]: [G; 1] = [v_160 * v_80]; let [v_163]: [G; 1] = [v_92 * v_162]; let [v_164]: [G; 1] = [v_161 + v_163]; let [v_165]: [G; 1] = [v_159 * v_80]; let [v_166]: [G; 1] = [v_160 * v_152]; let [v_167]: [G; 1] = [v_165 + v_166]; let [v_168]: [G; 1] = [v_124 * v_164]; let [v_169]: [G; 1] = [v_127 * v_167]; let [v_170]: [G; 1] = [v_92 * v_169]; let [v_171]: [G; 1] = [v_168 + v_170]; let [v_172]: [G; 1] = [v_124 * v_167]; let [v_173]: [G; 1] = [v_127 * v_164]; let [v_174]: [G; 1] = [v_172 + v_173]; let [v_175]: [G; 1] = [v_38 - v_11]; let [v_176]: [G; 1] = [v_175 * v_152]; let [v_177]: [G; 1] = [v_176 + v_163]; let [v_178]: [G; 1] = [v_175 * v_80]; let [v_179]: [G; 1] = [v_178 + v_166]; let [v_180]: [G; 1] = [v_124 * v_177]; let [v_181]: [G; 1] = [v_127 * v_179]; let [v_182]: [G; 1] = [v_92 * v_181]; let [v_183]: [G; 1] = [v_180 + v_182]; let [v_184]: [G; 1] = [v_124 * v_179]; let [v_185]: [G; 1] = [v_127 * v_177]; let [v_186]: [G; 1] = [v_184 + v_185]; let [v_187, v_188, v_189, v_190]: [G; 4] = context.load::<4>(168, v_25)?; seed.u8(609, v_187); seed.full(352, v_188); seed.full(360, v_189); seed.u32(592, v_190); let []: [G; 0] = 'yield_0: { match v_187.as_canonical_u64() { 1u64 => { let [v_191]: [G; 1] = [G::from_u64(0)]; let [v_192, v_193]: [G; 2] = context.call::<2>(170, 250, &[v_45, v_191])?; seed.full(368, v_192); seed.full(376, v_193); let [v_194, v_195]: [G; 2] = context.call::<2>(171, 250, &[v_44, v_191])?; seed.full(384, v_194); seed.full(392, v_195); let [v_196]: [G; 1] = [v_192 - v_194]; let [v_197]: [G; 1] = [v_193 - v_195]; let [v_198]: [G; 1] = [v_196 + v_171]; let [v_199]: [G; 1] = [v_197 + v_174]; let [v_200, v_201]: [G; 2] = context.call::<2>(176, 187, &[v_157, v_158, v_16, v_17, v_198, v_199])?; seed.full(400, v_200); seed.full(408, v_201); let [v_202]: [G; 1] = [G::from_u64(1)]; let [v_203, v_204]: [G; 2] = context.call::<2>(178, 250, &[v_45, v_202])?; seed.full(416, v_203); seed.full(424, v_204); let [v_205, v_206]: [G; 2] = context.call::<2>(179, 250, &[v_44, v_202])?; seed.full(432, v_205); seed.full(440, v_206); let [v_207]: [G; 1] = [v_203 - v_205]; let [v_208]: [G; 1] = [v_204 - v_206]; let [v_209]: [G; 1] = [v_207 + v_183]; let [v_210]: [G; 1] = [v_208 + v_186]; let [v_211, v_212]: [G; 2] = context.call::<2>(184, 187, &[v_200, v_201, v_16, v_17, v_209, v_210])?; seed.full(448, v_211); seed.full(456, v_212); break 'yield_0 []; }, 0u64 => { let [v_213]: [G; 1] = [G::from_u64(0)]; let [v_214]: [G; 1] = context.call::<1>(186, 242, &[v_25])?; seed.full(368, v_214); let [v_215]: [G; 1] = [G::from_u64(1)]; let [v_216, v_217]: [G; 2] = context.call::<2>(188, 194, &[v_157, v_158, v_16, v_17, v_25, v_213, v_214, v_213, v_26, v_26, v_215, v_213, v_213, v_213, v_213, v_213, v_213, v_213, v_171, v_174, v_183, v_186, v_12, v_80, v_13, v_80, v_14, v_80, v_15, v_80, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed.full(376, v_216); seed.full(384, v_217); break 'yield_0 []; }, _ => { return Err(no_match(200, v_187)); }, } }; let [v_220]: [G; 1] = context.call::<1>(189, 239, &[v_8, v_9])?; seed.full(464, v_220); let [v_221]: [G; 1] = [G::from_u64(0)]; let [v_222]: [G; 1] = context.call::<1>(191, 239, &[v_220, v_221])?; seed.u32(596, v_222); let [v_223]: [G; 1] = context.call::<1>(192, 189, &[v_222])?; seed.u32(600, v_223); let [v_224]: [G; 1] = context.call::<1>(193, 242, &[v_223])?; seed.full(472, v_224); let [v_227]: [G; 1] = [G::from_u64(1)]; let [v_228, v_229]: [G; 2] = context.call::<2>(198, 182, &[v_18, v_19, v_32])?; seed.full(480, v_228); seed.full(488, v_229); let [v_230, v_231]: [G; 2] = context.call::<2>(199, 197, &[v_223, v_228, v_229, v_227, v_221])?; seed.full(496, v_230); seed.full(504, v_231); let [v_246]: [G; 1] = context.returned::<1>(215)?; seed.u8(610, v_246); Ok(()) }, } }, _ => { Err(no_match(200, v_20)) }, } } + +fn pack_200_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 11] = context.load::<11>(0, v_0)?; seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_21.as_canonical_u64() { _ => { let [v_32]: [G; 1] = context.call::<1>(2, 239, &[v_2, v_9])?; seed[32] = v_32.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = context.call::<1>(7, 198, &[v_24])?; seed[33] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = context.call::<2>(8, 250, &[v_3, v_9])?; seed[34] = v_37.as_canonical_u64(); seed[35] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.call::<1>(9, 239, &[v_4, v_9])?; seed[36] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.call::<1>(11, 239, &[v_39, v_40])?; seed[37] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.call::<1>(12, 239, &[v_39, v_35])?; seed[38] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.call::<1>(13, 239, &[v_5, v_9])?; seed[39] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(14, 239, &[v_43, v_40])?; seed[40] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = context.call::<1>(15, 239, &[v_43, v_35])?; seed[41] = v_45.as_canonical_u64(); let [v_46, v_47]: [G; 2] = context.call::<2>(16, 250, &[v_1, v_9])?; seed[42] = v_46.as_canonical_u64(); seed[43] = v_47.as_canonical_u64(); let [v_57, v_58]: [G; 2] = 'yield_0: { match v_46.as_canonical_u64() { 0u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; let [v_49]: [G; 1] = context.store(18, &[v_48, v_48, v_48, v_48])?; seed[44] = v_49.as_canonical_u64(); break 'yield_0 [v_49, v_49]; }, 1u64 => { match v_6.as_canonical_u64() { 0u64 => { let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.store(20, &[v_50, v_50, v_50, v_50])?; seed[44] = v_51.as_canonical_u64(); break 'yield_0 [v_51, v_51]; }, 1u64 => { let [v_52]: [G; 1] = context.call::<1>(21, 239, &[v_7, v_47])?; seed[44] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(23, 239, &[v_52, v_53])?; seed[45] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.call::<1>(25, 239, &[v_52, v_55])?; seed[46] = v_56.as_canonical_u64(); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(200, v_6)); }, } }, _ => { return Err(no_match(200, v_46)); }, } }; let [v_59]: [G; 1] = context.call::<1>(26, 242, &[v_41])?; seed[47] = v_59.as_canonical_u64(); let [v_62]: [G; 1] = [G::from_u64(1)]; let [v_63]: [G; 1] = context.call::<1>(31, 242, &[v_42])?; seed[48] = v_63.as_canonical_u64(); let [v_66]: [G; 1] = context.call::<1>(35, 242, &[v_44])?; seed[49] = v_66.as_canonical_u64(); let [v_69]: [G; 1] = context.call::<1>(39, 242, &[v_45])?; seed[50] = v_69.as_canonical_u64(); let [v_72]: [G; 1] = context.call::<1>(43, 242, &[v_57])?; seed[51] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(47, 242, &[v_58])?; seed[52] = v_75.as_canonical_u64(); let [v_78, v_79]: [G; 2] = context.call::<2>(51, 182, &[v_18, v_19, v_32])?; seed[53] = v_78.as_canonical_u64(); seed[54] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = [G::from_u64(0)]; let [v_81]: [G; 1] = [v_78 - v_62]; let [v_82]: [G; 1] = [v_79 - v_80]; let [v_83]: [G; 1] = context.call::<1>(55, 183, &[v_32])?; seed[55] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [g_inverse_value(v_83)]; let [v_89]: [G; 1] = [v_18 - v_62]; let [v_90]: [G; 1] = [v_19 - v_80]; let [v_91]: [G; 1] = [v_89 * v_89]; let [v_92]: [G; 1] = [G::from_u64(7)]; let [v_93]: [G; 1] = [v_90 * v_90]; let [v_94]: [G; 1] = [v_92 * v_93]; let [v_95]: [G; 1] = [v_91 - v_94]; let [v_96]: [G; 1] = [g_inverse_value(v_95)]; let [v_101]: [G; 1] = [v_89 * v_96]; let [v_102]: [G; 1] = [v_80 - v_90]; let [v_103]: [G; 1] = [v_102 * v_96]; let [v_104]: [G; 1] = [v_81 * v_101]; let [v_105]: [G; 1] = [v_82 * v_103]; let [v_106]: [G; 1] = [v_92 * v_105]; let [v_107]: [G; 1] = [v_104 + v_106]; let [v_108]: [G; 1] = [v_81 * v_103]; let [v_109]: [G; 1] = [v_82 * v_101]; let [v_110]: [G; 1] = [v_108 + v_109]; let [v_111]: [G; 1] = [v_18 - v_84]; let [v_112]: [G; 1] = [v_111 * v_111]; let [v_113]: [G; 1] = [v_112 - v_94]; let [v_114]: [G; 1] = [g_inverse_value(v_113)]; let [v_119]: [G; 1] = [v_111 * v_114]; let [v_120]: [G; 1] = [v_102 * v_114]; let [v_121]: [G; 1] = [v_81 * v_119]; let [v_122]: [G; 1] = [v_82 * v_120]; let [v_123]: [G; 1] = [v_92 * v_122]; let [v_124]: [G; 1] = [v_121 + v_123]; let [v_125]: [G; 1] = [v_81 * v_120]; let [v_126]: [G; 1] = [v_82 * v_119]; let [v_127]: [G; 1] = [v_125 + v_126]; let [v_140]: [G; 1] = context.store(120, &[v_62, v_62, v_62, v_62])?; seed[56] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = context.store(121, &[v_80, v_38, v_80, v_140])?; seed[57] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = context.store(122, &[v_80, v_37, v_80, v_141])?; seed[58] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = context.store(123, &[v_80, v_11, v_80, v_142])?; seed[59] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = context.store(124, &[v_80, v_10, v_80, v_143])?; seed[60] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = context.store(125, &[v_80, v_15, v_80, v_144])?; seed[61] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = context.store(126, &[v_80, v_14, v_80, v_145])?; seed[62] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = context.store(127, &[v_80, v_13, v_80, v_146])?; seed[63] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = context.store(128, &[v_80, v_12, v_80, v_147])?; seed[64] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = context.call::<1>(129, 185, &[v_32])?; seed[65] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = context.call::<1>(130, 183, &[v_32])?; seed[66] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_149 * v_150]; let [v_152]: [G; 1] = [g_inverse_value(v_151)]; let [v_157, v_158]: [G; 2] = context.call::<2>(139, 191, &[v_80, v_80, v_16, v_17, v_23, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed[67] = v_157.as_canonical_u64(); seed[68] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [v_37 - v_10]; let [v_160]: [G; 1] = [v_80 - v_80]; let [v_161]: [G; 1] = [v_159 * v_152]; let [v_162]: [G; 1] = [v_160 * v_80]; let [v_163]: [G; 1] = [v_92 * v_162]; let [v_164]: [G; 1] = [v_161 + v_163]; let [v_165]: [G; 1] = [v_159 * v_80]; let [v_166]: [G; 1] = [v_160 * v_152]; let [v_167]: [G; 1] = [v_165 + v_166]; let [v_168]: [G; 1] = [v_124 * v_164]; let [v_169]: [G; 1] = [v_127 * v_167]; let [v_170]: [G; 1] = [v_92 * v_169]; let [v_171]: [G; 1] = [v_168 + v_170]; let [v_172]: [G; 1] = [v_124 * v_167]; let [v_173]: [G; 1] = [v_127 * v_164]; let [v_174]: [G; 1] = [v_172 + v_173]; let [v_175]: [G; 1] = [v_38 - v_11]; let [v_176]: [G; 1] = [v_175 * v_152]; let [v_177]: [G; 1] = [v_176 + v_163]; let [v_178]: [G; 1] = [v_175 * v_80]; let [v_179]: [G; 1] = [v_178 + v_166]; let [v_180]: [G; 1] = [v_124 * v_177]; let [v_181]: [G; 1] = [v_127 * v_179]; let [v_182]: [G; 1] = [v_92 * v_181]; let [v_183]: [G; 1] = [v_180 + v_182]; let [v_184]: [G; 1] = [v_124 * v_179]; let [v_185]: [G; 1] = [v_127 * v_177]; let [v_186]: [G; 1] = [v_184 + v_185]; let [v_187, v_188, v_189, v_190]: [G; 4] = context.load::<4>(168, v_25)?; seed[69] = v_187.as_canonical_u64(); seed[70] = v_188.as_canonical_u64(); seed[71] = v_189.as_canonical_u64(); seed[72] = v_190.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_187.as_canonical_u64() { 1u64 => { let [v_191]: [G; 1] = [G::from_u64(0)]; let [v_192, v_193]: [G; 2] = context.call::<2>(170, 250, &[v_45, v_191])?; seed[73] = v_192.as_canonical_u64(); seed[74] = v_193.as_canonical_u64(); let [v_194, v_195]: [G; 2] = context.call::<2>(171, 250, &[v_44, v_191])?; seed[75] = v_194.as_canonical_u64(); seed[76] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = [v_192 - v_194]; let [v_197]: [G; 1] = [v_193 - v_195]; let [v_198]: [G; 1] = [v_196 + v_171]; let [v_199]: [G; 1] = [v_197 + v_174]; let [v_200, v_201]: [G; 2] = context.call::<2>(176, 187, &[v_157, v_158, v_16, v_17, v_198, v_199])?; seed[77] = v_200.as_canonical_u64(); seed[78] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [G::from_u64(1)]; let [v_203, v_204]: [G; 2] = context.call::<2>(178, 250, &[v_45, v_202])?; seed[79] = v_203.as_canonical_u64(); seed[80] = v_204.as_canonical_u64(); let [v_205, v_206]: [G; 2] = context.call::<2>(179, 250, &[v_44, v_202])?; seed[81] = v_205.as_canonical_u64(); seed[82] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [v_203 - v_205]; let [v_208]: [G; 1] = [v_204 - v_206]; let [v_209]: [G; 1] = [v_207 + v_183]; let [v_210]: [G; 1] = [v_208 + v_186]; let [v_211, v_212]: [G; 2] = context.call::<2>(184, 187, &[v_200, v_201, v_16, v_17, v_209, v_210])?; seed[83] = v_211.as_canonical_u64(); seed[84] = v_212.as_canonical_u64(); break 'yield_0 []; }, 0u64 => { let [v_213]: [G; 1] = [G::from_u64(0)]; let [v_214]: [G; 1] = context.call::<1>(186, 242, &[v_25])?; seed[73] = v_214.as_canonical_u64(); let [v_215]: [G; 1] = [G::from_u64(1)]; let [v_216, v_217]: [G; 2] = context.call::<2>(188, 194, &[v_157, v_158, v_16, v_17, v_25, v_213, v_214, v_213, v_26, v_26, v_215, v_213, v_213, v_213, v_213, v_213, v_213, v_213, v_171, v_174, v_183, v_186, v_12, v_80, v_13, v_80, v_14, v_80, v_15, v_80, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed[74] = v_216.as_canonical_u64(); seed[75] = v_217.as_canonical_u64(); break 'yield_0 []; }, _ => { return Err(no_match(200, v_187)); }, } }; let [v_220]: [G; 1] = context.call::<1>(189, 239, &[v_8, v_9])?; seed[85] = v_220.as_canonical_u64(); let [v_221]: [G; 1] = [G::from_u64(0)]; let [v_222]: [G; 1] = context.call::<1>(191, 239, &[v_220, v_221])?; seed[86] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = context.call::<1>(192, 189, &[v_222])?; seed[87] = v_223.as_canonical_u64(); let [v_224]: [G; 1] = context.call::<1>(193, 242, &[v_223])?; seed[88] = v_224.as_canonical_u64(); let [v_227]: [G; 1] = [G::from_u64(1)]; let [v_228, v_229]: [G; 2] = context.call::<2>(198, 182, &[v_18, v_19, v_32])?; seed[89] = v_228.as_canonical_u64(); seed[90] = v_229.as_canonical_u64(); let [v_230, v_231]: [G; 2] = context.call::<2>(199, 197, &[v_223, v_228, v_229, v_227, v_221])?; seed[91] = v_230.as_canonical_u64(); seed[92] = v_231.as_canonical_u64(); let [v_245]: [G; 1] = [v_9 + v_227]; let [v_246]: [G; 1] = context.check_returned::<1>(215, 200, &[v_30, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_245, v_37, v_38, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19])?; seed[93] = v_246.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(200, v_20)) }, } } + +fn write_200(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 11] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31])]; row[offsets.auxiliaries + 1] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_30.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { match v_21.as_canonical_u64() { _ => { let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 12] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(32)]; let [v_34]: [G; 1] = [Bytes2::less_than(&v_32, &v_33)]; row[offsets.auxiliaries + 13] = v_34.as_canonical_u64(); let [v_36]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 14] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = [G::from_u64(seed[34]), G::from_u64(seed[35])]; row[offsets.auxiliaries + 15] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 17] = v_39.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[37])]; row[offsets.auxiliaries + 18] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[38])]; row[offsets.auxiliaries + 19] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 20] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[40])]; row[offsets.auxiliaries + 21] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = [G::from_u64(seed[41])]; row[offsets.auxiliaries + 22] = v_45.as_canonical_u64(); let [v_46, v_47]: [G; 2] = [G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 23] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_47.as_canonical_u64(); let [v_57, v_58]: [G; 2] = 'yield_0: { match v_46.as_canonical_u64() { 0u64 => { let [v_49]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 25] = v_49.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_49, v_49]; }, 1u64 => { match v_6.as_canonical_u64() { 0u64 => { let [v_51]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 25] = v_51.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_51, v_51]; }, 1u64 => { let [v_52]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 25] = v_52.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[45])]; row[offsets.auxiliaries + 26] = v_54.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[46])]; row[offsets.auxiliaries + 27] = v_56.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(200, v_6)); }, } }, _ => { return Err(no_match(200, v_46)); }, } }; row[offsets.auxiliaries + 28] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 30] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [v_59 - v_27]; let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; row[offsets.auxiliaries + 31] = g_inverse_value(v_60).as_canonical_u64(); row[offsets.auxiliaries + 32] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = [G::from_u64(1)]; let [v_63]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 33] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = [v_63 - v_27]; let [v_65]: [G; 1] = [G::from_bool(v_64.is_zero())]; row[offsets.auxiliaries + 34] = g_inverse_value(v_64).as_canonical_u64(); row[offsets.auxiliaries + 35] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(seed[49])]; row[offsets.auxiliaries + 36] = v_66.as_canonical_u64(); let [v_67]: [G; 1] = [v_66 - v_29]; let [v_68]: [G; 1] = [G::from_bool(v_67.is_zero())]; row[offsets.auxiliaries + 37] = g_inverse_value(v_67).as_canonical_u64(); row[offsets.auxiliaries + 38] = v_68.as_canonical_u64(); let [v_69]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 39] = v_69.as_canonical_u64(); let [v_70]: [G; 1] = [v_69 - v_29]; let [v_71]: [G; 1] = [G::from_bool(v_70.is_zero())]; row[offsets.auxiliaries + 40] = g_inverse_value(v_70).as_canonical_u64(); row[offsets.auxiliaries + 41] = v_71.as_canonical_u64(); let [v_72]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 42] = v_72.as_canonical_u64(); let [v_73]: [G; 1] = [v_72 - v_28]; let [v_74]: [G; 1] = [G::from_bool(v_73.is_zero())]; row[offsets.auxiliaries + 43] = g_inverse_value(v_73).as_canonical_u64(); row[offsets.auxiliaries + 44] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = [G::from_u64(seed[52])]; row[offsets.auxiliaries + 45] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [v_75 - v_28]; let [v_77]: [G; 1] = [G::from_bool(v_76.is_zero())]; row[offsets.auxiliaries + 46] = g_inverse_value(v_76).as_canonical_u64(); row[offsets.auxiliaries + 47] = v_77.as_canonical_u64(); let [v_78, v_79]: [G; 2] = [G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 48] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = [G::from_u64(0)]; let [v_81]: [G; 1] = [v_78 - v_62]; let [v_82]: [G; 1] = [v_79 - v_80]; let [v_83]: [G; 1] = [G::from_u64(seed[55])]; row[offsets.auxiliaries + 50] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [g_inverse_value(v_83)]; row[offsets.auxiliaries + 51] = v_84.as_canonical_u64(); let [v_85]: [G; 1] = [v_83 * v_84]; row[offsets.auxiliaries + 52] = v_85.as_canonical_u64(); let [v_86]: [G; 1] = [v_85 - v_62]; let [v_87]: [G; 1] = [v_83 * v_86]; row[offsets.auxiliaries + 53] = v_87.as_canonical_u64(); let [v_88]: [G; 1] = [v_84 * v_86]; row[offsets.auxiliaries + 54] = v_88.as_canonical_u64(); let [v_89]: [G; 1] = [v_18 - v_62]; let [v_90]: [G; 1] = [v_19 - v_80]; let [v_91]: [G; 1] = [v_89 * v_89]; row[offsets.auxiliaries + 55] = v_91.as_canonical_u64(); let [v_92]: [G; 1] = [G::from_u64(7)]; let [v_93]: [G; 1] = [v_90 * v_90]; row[offsets.auxiliaries + 56] = v_93.as_canonical_u64(); let [v_94]: [G; 1] = [v_92 * v_93]; let [v_95]: [G; 1] = [v_91 - v_94]; let [v_96]: [G; 1] = [g_inverse_value(v_95)]; row[offsets.auxiliaries + 57] = v_96.as_canonical_u64(); let [v_97]: [G; 1] = [v_95 * v_96]; row[offsets.auxiliaries + 58] = v_97.as_canonical_u64(); let [v_98]: [G; 1] = [v_97 - v_62]; let [v_99]: [G; 1] = [v_95 * v_98]; row[offsets.auxiliaries + 59] = v_99.as_canonical_u64(); let [v_100]: [G; 1] = [v_96 * v_98]; row[offsets.auxiliaries + 60] = v_100.as_canonical_u64(); let [v_101]: [G; 1] = [v_89 * v_96]; row[offsets.auxiliaries + 61] = v_101.as_canonical_u64(); let [v_102]: [G; 1] = [v_80 - v_90]; let [v_103]: [G; 1] = [v_102 * v_96]; row[offsets.auxiliaries + 62] = v_103.as_canonical_u64(); let [v_104]: [G; 1] = [v_81 * v_101]; row[offsets.auxiliaries + 63] = v_104.as_canonical_u64(); let [v_105]: [G; 1] = [v_82 * v_103]; row[offsets.auxiliaries + 64] = v_105.as_canonical_u64(); let [v_108]: [G; 1] = [v_81 * v_103]; row[offsets.auxiliaries + 65] = v_108.as_canonical_u64(); let [v_109]: [G; 1] = [v_82 * v_101]; row[offsets.auxiliaries + 66] = v_109.as_canonical_u64(); let [v_111]: [G; 1] = [v_18 - v_84]; let [v_112]: [G; 1] = [v_111 * v_111]; row[offsets.auxiliaries + 67] = v_112.as_canonical_u64(); let [v_113]: [G; 1] = [v_112 - v_94]; let [v_114]: [G; 1] = [g_inverse_value(v_113)]; row[offsets.auxiliaries + 68] = v_114.as_canonical_u64(); let [v_115]: [G; 1] = [v_113 * v_114]; row[offsets.auxiliaries + 69] = v_115.as_canonical_u64(); let [v_116]: [G; 1] = [v_115 - v_62]; let [v_117]: [G; 1] = [v_113 * v_116]; row[offsets.auxiliaries + 70] = v_117.as_canonical_u64(); let [v_118]: [G; 1] = [v_114 * v_116]; row[offsets.auxiliaries + 71] = v_118.as_canonical_u64(); let [v_119]: [G; 1] = [v_111 * v_114]; row[offsets.auxiliaries + 72] = v_119.as_canonical_u64(); let [v_120]: [G; 1] = [v_102 * v_114]; row[offsets.auxiliaries + 73] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = [v_81 * v_119]; row[offsets.auxiliaries + 74] = v_121.as_canonical_u64(); let [v_122]: [G; 1] = [v_82 * v_120]; row[offsets.auxiliaries + 75] = v_122.as_canonical_u64(); let [v_123]: [G; 1] = [v_92 * v_122]; let [v_124]: [G; 1] = [v_121 + v_123]; let [v_125]: [G; 1] = [v_81 * v_120]; row[offsets.auxiliaries + 76] = v_125.as_canonical_u64(); let [v_126]: [G; 1] = [v_82 * v_119]; row[offsets.auxiliaries + 77] = v_126.as_canonical_u64(); let [v_127]: [G; 1] = [v_125 + v_126]; let [v_128]: [G; 1] = [v_81 * v_81]; row[offsets.auxiliaries + 78] = v_128.as_canonical_u64(); let [v_129]: [G; 1] = [v_82 * v_82]; row[offsets.auxiliaries + 79] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [v_92 * v_129]; let [v_131]: [G; 1] = [v_128 - v_130]; let [v_132]: [G; 1] = [g_inverse_value(v_131)]; row[offsets.auxiliaries + 80] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [v_131 * v_132]; row[offsets.auxiliaries + 81] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [v_133 - v_62]; let [v_135]: [G; 1] = [v_131 * v_134]; row[offsets.auxiliaries + 82] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [v_132 * v_134]; row[offsets.auxiliaries + 83] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [v_81 * v_132]; row[offsets.auxiliaries + 84] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [v_80 - v_82]; let [v_139]: [G; 1] = [v_138 * v_132]; row[offsets.auxiliaries + 85] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 86] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 87] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 88] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 89] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [G::from_u64(seed[60])]; row[offsets.auxiliaries + 90] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 91] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [G::from_u64(seed[62])]; row[offsets.auxiliaries + 92] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [G::from_u64(seed[63])]; row[offsets.auxiliaries + 93] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [G::from_u64(seed[64])]; row[offsets.auxiliaries + 94] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(seed[65])]; row[offsets.auxiliaries + 95] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [G::from_u64(seed[66])]; row[offsets.auxiliaries + 96] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_149 * v_150]; row[offsets.auxiliaries + 97] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [g_inverse_value(v_151)]; row[offsets.auxiliaries + 98] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [v_151 * v_152]; row[offsets.auxiliaries + 99] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [v_153 - v_62]; let [v_155]: [G; 1] = [v_151 * v_154]; row[offsets.auxiliaries + 100] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [v_152 * v_154]; row[offsets.auxiliaries + 101] = v_156.as_canonical_u64(); let [v_157, v_158]: [G; 2] = [G::from_u64(seed[67]), G::from_u64(seed[68])]; row[offsets.auxiliaries + 102] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [v_37 - v_10]; let [v_160]: [G; 1] = [v_80 - v_80]; let [v_161]: [G; 1] = [v_159 * v_152]; row[offsets.auxiliaries + 104] = v_161.as_canonical_u64(); let [v_162]: [G; 1] = [v_160 * v_80]; let [v_163]: [G; 1] = [v_92 * v_162]; let [v_164]: [G; 1] = [v_161 + v_163]; let [v_165]: [G; 1] = [v_159 * v_80]; let [v_166]: [G; 1] = [v_160 * v_152]; let [v_167]: [G; 1] = [v_165 + v_166]; let [v_168]: [G; 1] = [v_124 * v_164]; row[offsets.auxiliaries + 105] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [v_127 * v_167]; row[offsets.auxiliaries + 106] = v_169.as_canonical_u64(); let [v_172]: [G; 1] = [v_124 * v_167]; row[offsets.auxiliaries + 107] = v_172.as_canonical_u64(); let [v_173]: [G; 1] = [v_127 * v_164]; row[offsets.auxiliaries + 108] = v_173.as_canonical_u64(); let [v_175]: [G; 1] = [v_38 - v_11]; let [v_176]: [G; 1] = [v_175 * v_152]; row[offsets.auxiliaries + 109] = v_176.as_canonical_u64(); let [v_177]: [G; 1] = [v_176 + v_163]; let [v_178]: [G; 1] = [v_175 * v_80]; let [v_179]: [G; 1] = [v_178 + v_166]; let [v_180]: [G; 1] = [v_124 * v_177]; row[offsets.auxiliaries + 110] = v_180.as_canonical_u64(); let [v_181]: [G; 1] = [v_127 * v_179]; row[offsets.auxiliaries + 111] = v_181.as_canonical_u64(); let [v_184]: [G; 1] = [v_124 * v_179]; row[offsets.auxiliaries + 112] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = [v_127 * v_177]; row[offsets.auxiliaries + 113] = v_185.as_canonical_u64(); let [v_187, v_188, v_189, v_190]: [G; 4] = [G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 114] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_190.as_canonical_u64(); let [v_218, v_219]: [G; 2] = 'yield_0: { match v_187.as_canonical_u64() { 1u64 => { let [v_192, v_193]: [G; 2] = [G::from_u64(seed[73]), G::from_u64(seed[74])]; row[offsets.auxiliaries + 118] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_193.as_canonical_u64(); let [v_194, v_195]: [G; 2] = [G::from_u64(seed[75]), G::from_u64(seed[76])]; row[offsets.auxiliaries + 120] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_195.as_canonical_u64(); let [v_200, v_201]: [G; 2] = [G::from_u64(seed[77]), G::from_u64(seed[78])]; row[offsets.auxiliaries + 122] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_201.as_canonical_u64(); let [v_203, v_204]: [G; 2] = [G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 124] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_204.as_canonical_u64(); let [v_205, v_206]: [G; 2] = [G::from_u64(seed[81]), G::from_u64(seed[82])]; row[offsets.auxiliaries + 126] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_206.as_canonical_u64(); let [v_211, v_212]: [G; 2] = [G::from_u64(seed[83]), G::from_u64(seed[84])]; row[offsets.auxiliaries + 128] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_212.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 [v_211, v_212]; }, 0u64 => { let [v_214]: [G; 1] = [G::from_u64(seed[73])]; row[offsets.auxiliaries + 118] = v_214.as_canonical_u64(); let [v_216, v_217]: [G; 2] = [G::from_u64(seed[74]), G::from_u64(seed[75])]; row[offsets.auxiliaries + 119] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_217.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 [v_216, v_217]; }, _ => { return Err(no_match(200, v_187)); }, } }; row[offsets.auxiliaries + 130] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_219.as_canonical_u64(); let [v_220]: [G; 1] = [G::from_u64(seed[85])]; row[offsets.auxiliaries + 132] = v_220.as_canonical_u64(); let [v_222]: [G; 1] = [G::from_u64(seed[86])]; row[offsets.auxiliaries + 133] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = [G::from_u64(seed[87])]; row[offsets.auxiliaries + 134] = v_223.as_canonical_u64(); let [v_224]: [G; 1] = [G::from_u64(seed[88])]; row[offsets.auxiliaries + 135] = v_224.as_canonical_u64(); let [v_225]: [G; 1] = [v_224 - v_36]; let [v_226]: [G; 1] = [G::from_bool(v_225.is_zero())]; row[offsets.auxiliaries + 136] = g_inverse_value(v_225).as_canonical_u64(); row[offsets.auxiliaries + 137] = v_226.as_canonical_u64(); let [v_228, v_229]: [G; 2] = [G::from_u64(seed[89]), G::from_u64(seed[90])]; row[offsets.auxiliaries + 138] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_229.as_canonical_u64(); let [v_230, v_231]: [G; 2] = [G::from_u64(seed[91]), G::from_u64(seed[92])]; row[offsets.auxiliaries + 140] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_231.as_canonical_u64(); let [v_232]: [G; 1] = [v_218 * v_137]; row[offsets.auxiliaries + 142] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [G::from_u64(7)]; let [v_234]: [G; 1] = [v_219 * v_139]; row[offsets.auxiliaries + 143] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [v_233 * v_234]; let [v_236]: [G; 1] = [v_232 + v_235]; let [v_237]: [G; 1] = [v_218 * v_139]; row[offsets.auxiliaries + 144] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [v_219 * v_137]; row[offsets.auxiliaries + 145] = v_238.as_canonical_u64(); let [v_239]: [G; 1] = [v_237 + v_238]; let [v_240]: [G; 1] = [v_236 - v_230]; let [v_241]: [G; 1] = [G::from_bool(v_240.is_zero())]; row[offsets.auxiliaries + 146] = g_inverse_value(v_240).as_canonical_u64(); row[offsets.auxiliaries + 147] = v_241.as_canonical_u64(); let [v_242]: [G; 1] = [v_239 - v_231]; let [v_243]: [G; 1] = [G::from_bool(v_242.is_zero())]; row[offsets.auxiliaries + 148] = g_inverse_value(v_242).as_canonical_u64(); row[offsets.auxiliaries + 149] = v_243.as_canonical_u64(); let [v_244]: [G; 1] = [v_241 * v_243]; row[offsets.auxiliaries + 150] = v_244.as_canonical_u64(); let [v_246]: [G; 1] = [G::from_u64(seed[93])]; row[offsets.auxiliaries + 151] = v_246.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(200, v_20)) }, } } + +static SCHEMA_200: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8], offsets: &[0, 512, 8, 16, 24, 32, 40, 604, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 605, 516, 152, 520, 160, 524, 168, 176, 184, 192, 528, 606, 607, 200, 208, 216, 532, 536, 224, 540, 544, 608, 232, 240, 548, 552, 248, 256, 264, 272, 280, 288, 296, 304, 312, 556, 560, 564, 568, 572, 576, 580, 584, 588, 320, 328, 336, 344, 609, 352, 360, 592, 368, 376, 384, 392, 400, 408, 416, 424, 432, 440, 448, 456, 464, 596, 600, 472, 480, 488, 496, 504, 610], bytes: 616 }; + +fn pack_217(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed[6] = v_9.as_canonical_u64(); seed[7] = v_10.as_canonical_u64(); seed[8] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 216, &[v_3, v_10])?; seed[9] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed[10] = v_14.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(217, v_9)) }, } }, _ => { Err(no_match(217, v_2)) }, } } + +fn pack_217_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_2); seed.u32(16, v_3); seed.u32(20, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed.u8(33, v_5); seed.u32(24, v_6); seed.u32(28, v_7); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed.u8(33, v_9); seed.u32(24, v_10); seed.u32(28, v_11); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 216, &[v_3, v_10])?; seed.u8(34, v_12); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed.u8(35, v_14); Ok(()) }, _ => { Err(no_match(217, v_9)) }, } }, _ => { Err(no_match(217, v_2)) }, } } + +fn pack_217_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed[6] = v_9.as_canonical_u64(); seed[7] = v_10.as_canonical_u64(); seed[8] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 216, &[v_3, v_10])?; seed[9] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = context.check_returned::<1>(8, 217, &[v_4, v_11])?; seed[10] = v_14.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(217, v_9)) }, } }, _ => { Err(no_match(217, v_2)) }, } } + +fn write_217(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_14.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(217, v_9)) }, } }, _ => { Err(no_match(217, v_2)) }, } } + +static SCHEMA_217: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 32, 16, 20, 33, 24, 28, 34, 35], bytes: 40 }; + +fn pack_227(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 226, &[v_0, v_8, v_16])?; seed[17] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(2, 226, &[v_1, v_9, v_17])?; seed[18] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(3, 226, &[v_2, v_10, v_18])?; seed[19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(4, 226, &[v_3, v_11, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(5, 226, &[v_4, v_12, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.call::<1>(6, 226, &[v_5, v_13, v_21])?; seed[22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(7, 226, &[v_6, v_14, v_22])?; seed[23] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed[24] = v_24.as_canonical_u64(); Ok(()) } + +fn pack_227_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 226, &[v_0, v_8, v_16])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(2, 226, &[v_1, v_9, v_17])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(3, 226, &[v_2, v_10, v_18])?; seed.full(24, v_19); let [v_20]: [G; 1] = context.call::<1>(4, 226, &[v_3, v_11, v_19])?; seed.full(32, v_20); let [v_21]: [G; 1] = context.call::<1>(5, 226, &[v_4, v_12, v_20])?; seed.full(40, v_21); let [v_22]: [G; 1] = context.call::<1>(6, 226, &[v_5, v_13, v_21])?; seed.full(48, v_22); let [v_23]: [G; 1] = context.call::<1>(7, 226, &[v_6, v_14, v_22])?; seed.full(56, v_23); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed.full(64, v_24); Ok(()) } + +fn pack_227_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 226, &[v_0, v_8, v_16])?; seed[17] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(2, 226, &[v_1, v_9, v_17])?; seed[18] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(3, 226, &[v_2, v_10, v_18])?; seed[19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(4, 226, &[v_3, v_11, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(5, 226, &[v_4, v_12, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.call::<1>(6, 226, &[v_5, v_13, v_21])?; seed[22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(7, 226, &[v_6, v_14, v_22])?; seed[23] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = context.check_returned::<1>(8, 226, &[v_7, v_15, v_23])?; seed[24] = v_24.as_canonical_u64(); Ok(()) } + +fn write_227(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_17]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 3] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 7] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 8] = v_24.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_227: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 8, 16, 24, 32, 40, 48, 56, 64], bytes: 88 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Sub(2, 3), Op::Call(1, vec![0, 4, 5], 1, false), Op::IORead(0, 1, 1), Op::Const(G::from_u64(0)), Op::Store(vec![8, 7, 6])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Mul(12, 12), Op::AssertEq(vec![13], vec![12], Some("u32_add: carry is not boolean".into()))], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::U8RangeCheck(12, 13), Op::U8RangeCheck(14, 15), Op::Const(G::from_u64(1)), Op::Sub(16, 17), Op::Const(G::from_u64(2)), Op::Sub(16, 19), Op::Mul(18, 20), Op::Mul(16, 21), Op::Const(G::from_u64(0)), Op::AssertEq(vec![22], vec![23], Some("u32_add3: carry is not in {0, 1, 2}".into()))], ctrl: Ctrl::Return(0, vec![12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 4), Op::U8Xor(1, 5), Op::U8Xor(2, 6), Op::U8Xor(3, 7)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 0, 1]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 0]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit7(0, 4), Op::U8XorSplit7(1, 5), Op::U8XorSplit7(2, 6), Op::U8XorSplit7(3, 7), Op::Add(8, 11), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit4(0, 4), Op::U8XorSplit4(1, 5), Op::U8XorSplit4(2, 6), Op::U8XorSplit4(3, 7), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9), Op::Add(8, 11)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 8), Op::Sub(1, 9), Op::Sub(2, 10), Op::Sub(3, 11), Op::Sub(4, 12), Op::Sub(5, 13), Op::Sub(6, 14), Op::Sub(7, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![24]) }))) }, layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(255), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".into())), Op::Const(G::from_u64(256)), Op::Mul(9, 1), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Const(G::from_u64(16777216)), Op::Mul(13, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 6), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(0, 25)], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(8, 1), Op::Const(G::from_u64(65536)), Op::Mul(10, 2), Op::Const(G::from_u64(16777216)), Op::Mul(12, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(14, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(16, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(18, 6), Op::Const(G::from_u64(72057594037927936)), Op::Mul(20, 7), Op::Add(19, 21), Op::Add(17, 22), Op::Add(15, 23), Op::Add(13, 24), Op::Add(11, 25), Op::Add(9, 26), Op::Add(0, 27)], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1020)), Op::Sub(7, 8), Op::Add(6, 9), Op::Add(5, 10), Op::Add(4, 11), Op::EqZero(12), Op::Add(2, 3), Op::Add(1, 14), Op::Add(0, 15), Op::EqZero(16), Op::Const(G::from_u64(1)), Op::Sub(18, 17), Op::Mul(13, 19), Op::Sub(18, 20)], ctrl: Ctrl::Return(0, vec![21]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::Const(G::from_u64(256)), Op::Mul(9, 2), Op::Const(G::from_u64(65536)), Op::Mul(11, 3), Op::Const(G::from_u64(16777216)), Op::Mul(13, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(21, 8), Op::Add(20, 22), Op::Add(18, 23), Op::Add(16, 24), Op::Add(14, 25), Op::Add(12, 26), Op::Add(10, 27), Op::Add(1, 28), Op::AssertEq(vec![29], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(8, 30), Op::Add(7, 31), Op::Add(6, 32), Op::Add(5, 33), Op::EqZero(34), Op::Add(3, 4), Op::Add(2, 36), Op::Add(1, 37), Op::EqZero(38), Op::Const(G::from_u64(1)), Op::Sub(40, 39), Op::Mul(35, 41), Op::Sub(40, 42), Op::AssertEq(vec![43], vec![40], None)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGInverse(0), Op::Mul(0, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 3), Op::Mul(0, 4), Op::Const(G::from_u64(0)), Op::AssertEq(vec![5], vec![6], None), Op::Mul(1, 4), Op::AssertEq(vec![7], vec![6], None)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![Op::Add(0, 2), Op::Add(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::Sub(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(2, 0), Op::Sub(2, 1)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(5, 6), Op::Add(4, 7), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(9, 10)], ctrl: Ctrl::Return(0, vec![8, 11]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(3, 4), Op::Sub(2, 5), Op::UnconstrainedGInverse(6), Op::Mul(6, 7), Op::Const(G::from_u64(1)), Op::Sub(8, 9), Op::Mul(6, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], None), Op::Mul(7, 10), Op::AssertEq(vec![13], vec![12], None), Op::Mul(0, 7), Op::Sub(12, 1), Op::Mul(15, 7)], ctrl: Ctrl::Return(0, vec![14, 16]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_22() -> Function { + Function { body: Block { ops: vec![Op::Mul(2, 2), Op::Const(G::from_u64(7)), Op::Mul(3, 3), Op::Mul(5, 6), Op::Sub(4, 7), Op::UnconstrainedGInverse(8), Op::Mul(8, 9), Op::Const(G::from_u64(1)), Op::Sub(10, 11), Op::Mul(8, 12), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], None), Op::Mul(9, 12), Op::AssertEq(vec![15], vec![14], None), Op::Mul(2, 9), Op::Sub(14, 3), Op::Mul(17, 9), Op::Mul(0, 16), Op::Mul(1, 18), Op::Mul(5, 20), Op::Add(19, 21), Op::Mul(0, 18), Op::Mul(1, 16), Op::Add(23, 24)], ctrl: Ctrl::Return(0, vec![22, 25]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 13, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_23() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::EqZero(4), Op::Sub(1, 3), Op::EqZero(6), Op::Mul(5, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_24() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![4, 6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_25() -> Function { + Function { body: Block { ops: vec![Op::Call(24, vec![0], 2, false), Op::Call(24, vec![2], 2, false), Op::Call(24, vec![4], 2, false), Op::Call(24, vec![6], 2, false), Op::Call(24, vec![8], 2, false), Op::Call(24, vec![10], 2, false), Op::Call(24, vec![12], 2, false), Op::Call(24, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_26() -> Function { + Function { body: Block { ops: vec![Op::Call(25, vec![0], 9, false), Op::Call(12, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_27() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 1), Op::Const(G::from_u64(1)), Op::Add(0, 3)], ctrl: Ctrl::Return(0, vec![2, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_28() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 8), Op::Const(G::from_u64(8)), Op::Add(0, 10)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_29() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(12, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_30() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![9], 9, true), Op::Const(G::from_u64(256)), Op::Mul(19, 2), Op::Const(G::from_u64(65536)), Op::Mul(21, 3), Op::Const(G::from_u64(16777216)), Op::Mul(23, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(25, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(27, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(29, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 8), Op::Add(30, 32), Op::Add(28, 33), Op::Add(26, 34), Op::Add(24, 35), Op::Add(22, 36), Op::Add(20, 37), Op::Add(1, 38), Op::Mul(19, 11), Op::Mul(21, 12), Op::Mul(23, 13), Op::Mul(25, 14), Op::Mul(27, 15), Op::Mul(29, 16), Op::Mul(31, 17), Op::Add(45, 46), Op::Add(44, 47), Op::Add(43, 48), Op::Add(42, 49), Op::Add(41, 50), Op::Add(40, 51), Op::Add(10, 52)], ctrl: Ctrl::Return(0, vec![39, 53, 18]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 19, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_31() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![9], 9, true), Op::Call(28, vec![18], 9, true), Op::Call(28, vec![27], 9, true)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_32() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_33() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(27, vec![0], 2, true), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(33, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_34() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_35() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(35, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_36() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(37, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_37() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![10], 9, true), Op::Const(G::from_u64(256)), Op::Mul(20, 3), Op::Const(G::from_u64(65536)), Op::Mul(22, 4), Op::Const(G::from_u64(16777216)), Op::Mul(24, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(26, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(28, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(30, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(32, 9), Op::Add(31, 33), Op::Add(29, 34), Op::Add(27, 35), Op::Add(25, 36), Op::Add(23, 37), Op::Add(21, 38), Op::Add(2, 39), Op::Mul(20, 12), Op::Mul(22, 13), Op::Mul(24, 14), Op::Mul(26, 15), Op::Mul(28, 16), Op::Mul(30, 17), Op::Mul(32, 18), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(11, 53), Op::Const(G::from_u64(1)), Op::Sub(1, 55), Op::Call(37, vec![19, 56], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![59, 40, 54, 57])], ctrl: Ctrl::Return(1, vec![60, 58]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_38() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(39, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_39() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![10], 9, true), Op::Call(28, vec![19], 9, true), Op::Call(28, vec![28], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(39, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_40() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(41, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_41() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(34, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(41, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_42() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(43, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_43() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(41, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(43, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_44() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(45, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_45() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(45, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_46() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(47, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_47() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(44, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(47, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_48() -> Function { + Function { body: Block { ops: vec![Op::Call(38, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_49() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(50, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_50() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(38, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(50, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_51() -> Function { + Function { body: Block { ops: vec![Op::Call(38, vec![0], 2, false), Op::Call(38, vec![2], 2, false), Op::Call(38, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_52() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(43, vec![2, 1], 2, false), Op::Call(38, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_53() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(54, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_54() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(43, vec![3, 2], 2, false), Op::Call(38, vec![5], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(54, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_55() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 2, true), Op::Call(29, vec![2], 2, false), Op::Call(45, vec![4, 3], 2, false), Op::Call(38, vec![6], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_56() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(57, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_57() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(27, vec![0], 2, true), Op::Call(29, vec![3], 2, false), Op::Call(45, vec![5, 4], 2, false), Op::Call(38, vec![7], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(57, vec![9, 11], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 2, 6, 8, 12])], ctrl: Ctrl::Return(1, vec![15, 13]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_58() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(50, vec![2, 1], 2, false), Op::Call(34, vec![4], 2, false), Op::Call(29, vec![6], 2, false), Op::Call(54, vec![8, 7], 2, false), Op::Call(29, vec![10], 2, false), Op::Call(57, vec![12, 11], 2, false), Op::Call(36, vec![14], 2, false), Op::Call(28, vec![16], 9, true)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 26, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_59() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 2, true)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(46, vec![2], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_60() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![2, 1], 2, false), Op::Call(38, vec![4], 2, false), Op::Call(38, vec![6], 2, false), Op::Call(38, vec![8], 2, false), Op::Call(36, vec![10], 2, false), Op::Call(29, vec![12], 2, false), Op::Call(33, vec![14, 13], 2, false), Op::Call(29, vec![16], 2, false), Op::Call(50, vec![18, 17], 2, false), Op::Call(34, vec![20], 2, false), Op::Call(29, vec![22], 2, false), Op::Call(54, vec![24, 23], 2, false), Op::Call(29, vec![26], 2, false), Op::Call(57, vec![28, 27], 2, false), Op::Call(36, vec![30], 2, false), Op::Call(28, vec![32], 9, true), Op::Call(46, vec![41], 2, false), Op::Call(59, vec![43], 3, false), Op::Call(46, vec![46], 2, false), Op::Call(46, vec![48], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 7, 9, 11, 15, 19, 21, 25, 29, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 44, 45, 47, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_61() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![2, 1], 2, false), Op::Call(38, vec![4], 2, false), Op::Call(29, vec![6], 2, false), Op::Call(33, vec![8, 7], 2, false), Op::Call(29, vec![10], 2, false), Op::Call(41, vec![12, 11], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 14]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_62() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(63, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_63() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![3, 2], 2, false), Op::Call(38, vec![5], 2, false), Op::Call(29, vec![7], 2, false), Op::Call(33, vec![9, 8], 2, false), Op::Call(29, vec![11], 2, false), Op::Call(41, vec![13, 12], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 16), Op::Call(63, vec![15, 17], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![20, 4, 6, 10, 14, 18])], ctrl: Ctrl::Return(1, vec![21, 19]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_64() -> Function { + Function { body: Block { ops: vec![Op::Call(34, vec![0], 2, false), Op::Call(28, vec![2], 9, true)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_65() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(66, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_66() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(34, vec![0], 2, false), Op::Call(28, vec![3], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Call(66, vec![12, 14], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![17, 2, 4, 5, 6, 7, 8, 9, 10, 11, 15])], ctrl: Ctrl::Return(1, vec![18, 16]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_67() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(68, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_68() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(60, vec![0], 25, false), Op::Const(G::from_u64(1)), Op::Sub(1, 27), Op::Call(68, vec![26, 28], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![31, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 29])], ctrl: Ctrl::Return(1, vec![32, 30]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_69() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(63, vec![2, 1], 2, false), Op::Call(29, vec![4], 2, false), Op::Call(66, vec![6, 5], 2, false), Op::Call(29, vec![8], 2, false), Op::Call(68, vec![10, 9], 2, false)], ctrl: Ctrl::Return(0, vec![3, 7, 11, 12]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 13, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_70() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(4, 1), Op::Const(G::from_u64(65536)), Op::Mul(6, 2), Op::Const(G::from_u64(16777216)), Op::Mul(8, 3), Op::Add(7, 9), Op::Add(5, 10), Op::Add(0, 11)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_71() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(32, 1), Op::Const(G::from_u64(65536)), Op::Mul(34, 2), Op::Const(G::from_u64(16777216)), Op::Mul(36, 3), Op::Add(35, 37), Op::Add(33, 38), Op::Add(0, 39), Op::Mul(32, 5), Op::Mul(34, 6), Op::Mul(36, 7), Op::Add(42, 43), Op::Add(41, 44), Op::Add(4, 45), Op::Mul(32, 9), Op::Mul(34, 10), Op::Mul(36, 11), Op::Add(48, 49), Op::Add(47, 50), Op::Add(8, 51), Op::Mul(32, 13), Op::Mul(34, 14), Op::Mul(36, 15), Op::Add(54, 55), Op::Add(53, 56), Op::Add(12, 57), Op::Mul(32, 17), Op::Mul(34, 18), Op::Mul(36, 19), Op::Add(60, 61), Op::Add(59, 62), Op::Add(16, 63), Op::Mul(32, 21), Op::Mul(34, 22), Op::Mul(36, 23), Op::Add(66, 67), Op::Add(65, 68), Op::Add(20, 69), Op::Mul(32, 25), Op::Mul(34, 26), Op::Mul(36, 27), Op::Add(72, 73), Op::Add(71, 74), Op::Add(24, 75), Op::Mul(32, 29), Op::Mul(34, 30), Op::Mul(36, 31), Op::Add(78, 79), Op::Add(77, 80), Op::Add(28, 81)], ctrl: Ctrl::Return(0, vec![40, 46, 52, 58, 64, 70, 76, 82]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_72() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(75, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(74, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_73() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(34, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![68, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(73, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68], 34, false)], ctrl: Ctrl::Match(69, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![103, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 102]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(34, 102)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Mul(104, 33), Op::Add(103, 170), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![172, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 174, 175, 176, 177, 178, 179, 174, 180, 181, 182, 183, 184, 185, 186, 187, 188, 172, 172, 172, 172, 172, 172, 172, 172, 173, 172, 172, 172, 171, 172, 172, 172, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![172, 102, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220])], ctrl: Ctrl::Return(2, vec![172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 221]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![170, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 172, 173, 174, 175, 176, 177, 172, 178, 179, 180, 181, 182, 183, 184, 185, 186, 170, 170, 170, 170, 170, 170, 170, 170, 171, 170, 170, 170, 103, 170, 170, 170, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![170, 102, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218])], ctrl: Ctrl::Return(3, vec![170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 219]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_74() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(34, 2)], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(73, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 69], 34, false)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Call(74, vec![103], 32, false)], ctrl: Ctrl::Return(1, vec![104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![104, 103, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102]), Op::Call(74, vec![105], 32, false)], ctrl: Ctrl::Return(2, vec![106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_75() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(78, vec![1, 2, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 1])], ctrl: Ctrl::Match(2, [(G::from_u64(63), Block { ops: vec![Op::Call(79, vec![9, 11, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 12), Op::Add(3, 12), Op::Call(75, vec![9, 11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_76() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 96)], ctrl: Ctrl::Match(97, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 99)], ctrl: Ctrl::Match(100, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 102)], ctrl: Ctrl::Match(103, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 105)], ctrl: Ctrl::Match(106, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 108)], ctrl: Ctrl::Match(109, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 111)], ctrl: Ctrl::Match(112, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 114)], ctrl: Ctrl::Match(115, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 117)], ctrl: Ctrl::Match(118, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 123)], ctrl: Ctrl::Match(124, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 126)], ctrl: Ctrl::Match(127, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 129)], ctrl: Ctrl::Match(130, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 132)], ctrl: Ctrl::Match(133, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 135)], ctrl: Ctrl::Match(136, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 138)], ctrl: Ctrl::Match(139, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 141)], ctrl: Ctrl::Match(142, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 144)], ctrl: Ctrl::Match(145, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 147)], ctrl: Ctrl::Match(148, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 150)], ctrl: Ctrl::Match(151, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 153)], ctrl: Ctrl::Match(154, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 156)], ctrl: Ctrl::Match(157, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 159)], ctrl: Ctrl::Match(160, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 165)], ctrl: Ctrl::Match(166, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 171)], ctrl: Ctrl::Match(172, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 174)], ctrl: Ctrl::Match(175, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 177)], ctrl: Ctrl::Match(178, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 180)], ctrl: Ctrl::Match(181, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 183)], ctrl: Ctrl::Match(184, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 186)], ctrl: Ctrl::Match(187, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 189)], ctrl: Ctrl::Match(190, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 29, 26, 23, 20, 17, 14, 11, 8, 5, 2]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_77() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(77, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_78() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Add(6, 7), Op::Add(8, 17), Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![51, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 60, 61, 62, 63, 64, 65, 60, 66, 67, 68, 69, 70, 71, 72, 73, 74, 52, 53, 54, 55, 56, 57, 58, 59, 51, 51, 51, 51, 18, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51], 32, false), Op::Store(vec![51, 5, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106])], ctrl: Ctrl::Return(0, vec![107]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Load(32, 4), Op::Store(vec![9, 5, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41])], ctrl: Ctrl::Return(9, vec![42]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(8, 3), Op::Call(2, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Sub(2, 1), Op::EqZero(19), Op::Mul(20, 6), Op::Add(18, 21), Op::Add(7, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(77, vec![0, 25], 1, false), Op::Call(76, vec![26], 64, false), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![138, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 123, 129, 130, 131, 132, 133, 134, 135, 136, 137, 9, 10, 11, 12, 13, 14, 15, 16, 1, 138, 138, 138, 23, 138, 138, 138, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90], 32, false), Op::Store(vec![138, 5, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170])], ctrl: Ctrl::Return(10, vec![171]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_79() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(76, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(249, vec![0], 1, false), Op::Load(8, 3), Op::Call(2, vec![74, 75, 76, 77, 78, 79, 80, 81], 1, false), Op::Mul(73, 82), Op::Mul(8, 83), Op::Add(84, 7), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(0)), Op::Call(83, vec![150, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 74, 75, 76, 77, 78, 79, 80, 81, 149, 150, 150, 150, 85, 150, 150, 150, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Store(vec![150, 5, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182]), Op::Const(G::from_u64(1)), Op::Store(vec![184, 184, 184]), Op::Call(11, vec![74, 75, 76, 77, 78, 79, 80, 81], 8, false), Op::Store(vec![186, 187, 188, 189, 190, 191, 192, 193]), Op::Store(vec![86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]), Op::Call(75, vec![0, 185, 150, 150, 194, 195, 183], 1, false)], ctrl: Ctrl::Return(0, vec![196]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(249, vec![0], 1, false), Op::Mul(73, 7), Op::Call(249, vec![0], 1, false), Op::Load(8, 3), Op::Call(2, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(84, 8), Op::Mul(75, 85), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(86, 90), Op::Add(74, 91), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![141, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 126, 127, 128, 129, 130, 131, 126, 132, 133, 134, 135, 136, 137, 138, 139, 140, 76, 77, 78, 79, 80, 81, 82, 83, 125, 141, 141, 141, 92, 141, 141, 141, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Const(G::from_u64(1)), Op::Store(vec![174, 174, 174]), Op::Add(2, 174), Op::Store(vec![142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173]), Op::Call(75, vec![0, 175, 141, 176, 3, 177, 5], 1, false)], ctrl: Ctrl::Return(1, vec![178]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_80() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![16, 17, 18, 19]), Op::U8RangeCheck(24, 25), Op::U8RangeCheck(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Const(G::from_u64(2)), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(28, 33), Op::Const(G::from_u64(0)), Op::AssertEq(vec![34], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(12, 24), Op::U8Xor(13, 25), Op::U8Xor(14, 26), Op::U8Xor(15, 27), Op::UnconstrainedU32Add(vec![8, 9, 10, 11], vec![38, 39, 36, 37]), Op::U8RangeCheck(40, 41), Op::U8RangeCheck(42, 43), Op::Mul(44, 44), Op::AssertEq(vec![45], vec![44], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(4, 40), Op::U8XorSplit4(5, 41), Op::U8XorSplit4(6, 42), Op::U8XorSplit4(7, 43), Op::Add(48, 51), Op::Add(50, 53), Op::Add(52, 47), Op::Add(46, 49), Op::UnconstrainedU32Add3(vec![24, 25, 26, 27], vec![54, 55, 56, 57], vec![20, 21, 22, 23]), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::Sub(62, 29), Op::Sub(62, 31), Op::Mul(63, 64), Op::Mul(62, 65), Op::AssertEq(vec![66], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(38, 58), Op::U8Xor(39, 59), Op::U8Xor(36, 60), Op::U8Xor(37, 61), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![68, 69, 70, 67]), Op::U8RangeCheck(71, 72), Op::U8RangeCheck(73, 74), Op::Mul(75, 75), Op::AssertEq(vec![76], vec![75], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(54, 71), Op::U8XorSplit7(55, 72), Op::U8XorSplit7(56, 73), Op::U8XorSplit7(57, 74), Op::Add(77, 80), Op::Add(79, 82), Op::Add(81, 84), Op::Add(83, 78)], ctrl: Ctrl::Return(0, vec![58, 59, 60, 61, 85, 86, 87, 88, 71, 72, 73, 74, 68, 69, 70, 67]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 47, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_81() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![16, 17, 18, 19], vec![64, 65, 66, 67]), Op::U8RangeCheck(128, 129), Op::U8RangeCheck(130, 131), Op::Const(G::from_u64(1)), Op::Sub(132, 133), Op::Const(G::from_u64(2)), Op::Sub(132, 135), Op::Mul(134, 136), Op::Mul(132, 137), Op::Const(G::from_u64(0)), Op::AssertEq(vec![138], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(48, 128), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::UnconstrainedU32Add(vec![32, 33, 34, 35], vec![142, 143, 140, 141]), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::Mul(148, 148), Op::AssertEq(vec![149], vec![148], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(16, 144), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::Add(152, 155), Op::Add(154, 157), Op::Add(156, 151), Op::Add(150, 153), Op::UnconstrainedU32Add3(vec![128, 129, 130, 131], vec![158, 159, 160, 161], vec![68, 69, 70, 71]), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::Sub(166, 133), Op::Sub(166, 135), Op::Mul(167, 168), Op::Mul(166, 169), Op::AssertEq(vec![170], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(142, 162), Op::U8Xor(143, 163), Op::U8Xor(140, 164), Op::U8Xor(141, 165), Op::UnconstrainedU32Add(vec![144, 145, 146, 147], vec![172, 173, 174, 171]), Op::U8RangeCheck(175, 176), Op::U8RangeCheck(177, 178), Op::Mul(179, 179), Op::AssertEq(vec![180], vec![179], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(158, 175), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::Add(181, 184), Op::Add(183, 186), Op::Add(185, 188), Op::Add(187, 182), Op::UnconstrainedU32Add3(vec![4, 5, 6, 7], vec![20, 21, 22, 23], vec![72, 73, 74, 75]), Op::U8RangeCheck(193, 194), Op::U8RangeCheck(195, 196), Op::Sub(197, 133), Op::Sub(197, 135), Op::Mul(198, 199), Op::Mul(197, 200), Op::AssertEq(vec![201], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(52, 193), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::UnconstrainedU32Add(vec![36, 37, 38, 39], vec![204, 205, 202, 203]), Op::U8RangeCheck(206, 207), Op::U8RangeCheck(208, 209), Op::Mul(210, 210), Op::AssertEq(vec![211], vec![210], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(20, 206), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::Add(214, 217), Op::Add(216, 219), Op::Add(218, 213), Op::Add(212, 215), Op::UnconstrainedU32Add3(vec![193, 194, 195, 196], vec![220, 221, 222, 223], vec![76, 77, 78, 79]), Op::U8RangeCheck(224, 225), Op::U8RangeCheck(226, 227), Op::Sub(228, 133), Op::Sub(228, 135), Op::Mul(229, 230), Op::Mul(228, 231), Op::AssertEq(vec![232], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(204, 224), Op::U8Xor(205, 225), Op::U8Xor(202, 226), Op::U8Xor(203, 227), Op::UnconstrainedU32Add(vec![206, 207, 208, 209], vec![234, 235, 236, 233]), Op::U8RangeCheck(237, 238), Op::U8RangeCheck(239, 240), Op::Mul(241, 241), Op::AssertEq(vec![242], vec![241], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(220, 237), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::Add(243, 246), Op::Add(245, 248), Op::Add(247, 250), Op::Add(249, 244), Op::UnconstrainedU32Add3(vec![8, 9, 10, 11], vec![24, 25, 26, 27], vec![80, 81, 82, 83]), Op::U8RangeCheck(255, 256), Op::U8RangeCheck(257, 258), Op::Sub(259, 133), Op::Sub(259, 135), Op::Mul(260, 261), Op::Mul(259, 262), Op::AssertEq(vec![263], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(56, 255), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![266, 267, 264, 265]), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::Mul(272, 272), Op::AssertEq(vec![273], vec![272], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(24, 268), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::Add(276, 279), Op::Add(278, 281), Op::Add(280, 275), Op::Add(274, 277), Op::UnconstrainedU32Add3(vec![255, 256, 257, 258], vec![282, 283, 284, 285], vec![84, 85, 86, 87]), Op::U8RangeCheck(286, 287), Op::U8RangeCheck(288, 289), Op::Sub(290, 133), Op::Sub(290, 135), Op::Mul(291, 292), Op::Mul(290, 293), Op::AssertEq(vec![294], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(266, 286), Op::U8Xor(267, 287), Op::U8Xor(264, 288), Op::U8Xor(265, 289), Op::UnconstrainedU32Add(vec![268, 269, 270, 271], vec![296, 297, 298, 295]), Op::U8RangeCheck(299, 300), Op::U8RangeCheck(301, 302), Op::Mul(303, 303), Op::AssertEq(vec![304], vec![303], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(282, 299), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::Add(305, 308), Op::Add(307, 310), Op::Add(309, 312), Op::Add(311, 306), Op::UnconstrainedU32Add3(vec![12, 13, 14, 15], vec![28, 29, 30, 31], vec![88, 89, 90, 91]), Op::U8RangeCheck(317, 318), Op::U8RangeCheck(319, 320), Op::Sub(321, 133), Op::Sub(321, 135), Op::Mul(322, 323), Op::Mul(321, 324), Op::AssertEq(vec![325], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(60, 317), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::UnconstrainedU32Add(vec![44, 45, 46, 47], vec![328, 329, 326, 327]), Op::U8RangeCheck(330, 331), Op::U8RangeCheck(332, 333), Op::Mul(334, 334), Op::AssertEq(vec![335], vec![334], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(28, 330), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::Add(338, 341), Op::Add(340, 343), Op::Add(342, 337), Op::Add(336, 339), Op::UnconstrainedU32Add3(vec![317, 318, 319, 320], vec![344, 345, 346, 347], vec![92, 93, 94, 95]), Op::U8RangeCheck(348, 349), Op::U8RangeCheck(350, 351), Op::Sub(352, 133), Op::Sub(352, 135), Op::Mul(353, 354), Op::Mul(352, 355), Op::AssertEq(vec![356], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(328, 348), Op::U8Xor(329, 349), Op::U8Xor(326, 350), Op::U8Xor(327, 351), Op::UnconstrainedU32Add(vec![330, 331, 332, 333], vec![358, 359, 360, 357]), Op::U8RangeCheck(361, 362), Op::U8RangeCheck(363, 364), Op::Mul(365, 365), Op::AssertEq(vec![366], vec![365], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(344, 361), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::Add(367, 370), Op::Add(369, 372), Op::Add(371, 374), Op::Add(373, 368), Op::UnconstrainedU32Add3(vec![162, 163, 164, 165], vec![251, 252, 253, 254], vec![96, 97, 98, 99]), Op::U8RangeCheck(379, 380), Op::U8RangeCheck(381, 382), Op::Sub(383, 133), Op::Sub(383, 135), Op::Mul(384, 385), Op::Mul(383, 386), Op::AssertEq(vec![387], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(358, 379), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(357, 382), Op::UnconstrainedU32Add(vec![299, 300, 301, 302], vec![390, 391, 388, 389]), Op::U8RangeCheck(392, 393), Op::U8RangeCheck(394, 395), Op::Mul(396, 396), Op::AssertEq(vec![397], vec![396], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(251, 392), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::Add(400, 403), Op::Add(402, 405), Op::Add(404, 399), Op::Add(398, 401), Op::UnconstrainedU32Add3(vec![379, 380, 381, 382], vec![406, 407, 408, 409], vec![100, 101, 102, 103]), Op::U8RangeCheck(410, 411), Op::U8RangeCheck(412, 413), Op::Sub(414, 133), Op::Sub(414, 135), Op::Mul(415, 416), Op::Mul(414, 417), Op::AssertEq(vec![418], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(390, 410), Op::U8Xor(391, 411), Op::U8Xor(388, 412), Op::U8Xor(389, 413), Op::UnconstrainedU32Add(vec![392, 393, 394, 395], vec![420, 421, 422, 419]), Op::U8RangeCheck(423, 424), Op::U8RangeCheck(425, 426), Op::Mul(427, 427), Op::AssertEq(vec![428], vec![427], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(406, 423), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::Add(429, 432), Op::Add(431, 434), Op::Add(433, 436), Op::Add(435, 430), Op::UnconstrainedU32Add3(vec![224, 225, 226, 227], vec![313, 314, 315, 316], vec![104, 105, 106, 107]), Op::U8RangeCheck(441, 442), Op::U8RangeCheck(443, 444), Op::Sub(445, 133), Op::Sub(445, 135), Op::Mul(446, 447), Op::Mul(445, 448), Op::AssertEq(vec![449], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(172, 441), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(171, 444), Op::UnconstrainedU32Add(vec![361, 362, 363, 364], vec![452, 453, 450, 451]), Op::U8RangeCheck(454, 455), Op::U8RangeCheck(456, 457), Op::Mul(458, 458), Op::AssertEq(vec![459], vec![458], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(313, 454), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::Add(462, 465), Op::Add(464, 467), Op::Add(466, 461), Op::Add(460, 463), Op::UnconstrainedU32Add3(vec![441, 442, 443, 444], vec![468, 469, 470, 471], vec![108, 109, 110, 111]), Op::U8RangeCheck(472, 473), Op::U8RangeCheck(474, 475), Op::Sub(476, 133), Op::Sub(476, 135), Op::Mul(477, 478), Op::Mul(476, 479), Op::AssertEq(vec![480], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(452, 472), Op::U8Xor(453, 473), Op::U8Xor(450, 474), Op::U8Xor(451, 475), Op::UnconstrainedU32Add(vec![454, 455, 456, 457], vec![482, 483, 484, 481]), Op::U8RangeCheck(485, 486), Op::U8RangeCheck(487, 488), Op::Mul(489, 489), Op::AssertEq(vec![490], vec![489], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(468, 485), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::Add(491, 494), Op::Add(493, 496), Op::Add(495, 498), Op::Add(497, 492), Op::UnconstrainedU32Add3(vec![286, 287, 288, 289], vec![375, 376, 377, 378], vec![112, 113, 114, 115]), Op::U8RangeCheck(503, 504), Op::U8RangeCheck(505, 506), Op::Sub(507, 133), Op::Sub(507, 135), Op::Mul(508, 509), Op::Mul(507, 510), Op::AssertEq(vec![511], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(234, 503), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(233, 506), Op::UnconstrainedU32Add(vec![175, 176, 177, 178], vec![514, 515, 512, 513]), Op::U8RangeCheck(516, 517), Op::U8RangeCheck(518, 519), Op::Mul(520, 520), Op::AssertEq(vec![521], vec![520], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(375, 516), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::Add(524, 527), Op::Add(526, 529), Op::Add(528, 523), Op::Add(522, 525), Op::UnconstrainedU32Add3(vec![503, 504, 505, 506], vec![530, 531, 532, 533], vec![116, 117, 118, 119]), Op::U8RangeCheck(534, 535), Op::U8RangeCheck(536, 537), Op::Sub(538, 133), Op::Sub(538, 135), Op::Mul(539, 540), Op::Mul(538, 541), Op::AssertEq(vec![542], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(514, 534), Op::U8Xor(515, 535), Op::U8Xor(512, 536), Op::U8Xor(513, 537), Op::UnconstrainedU32Add(vec![516, 517, 518, 519], vec![544, 545, 546, 543]), Op::U8RangeCheck(547, 548), Op::U8RangeCheck(549, 550), Op::Mul(551, 551), Op::AssertEq(vec![552], vec![551], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(530, 547), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::Add(553, 556), Op::Add(555, 558), Op::Add(557, 560), Op::Add(559, 554), Op::UnconstrainedU32Add3(vec![348, 349, 350, 351], vec![189, 190, 191, 192], vec![120, 121, 122, 123]), Op::U8RangeCheck(565, 566), Op::U8RangeCheck(567, 568), Op::Sub(569, 133), Op::Sub(569, 135), Op::Mul(570, 571), Op::Mul(569, 572), Op::AssertEq(vec![573], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(296, 565), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(295, 568), Op::UnconstrainedU32Add(vec![237, 238, 239, 240], vec![576, 577, 574, 575]), Op::U8RangeCheck(578, 579), Op::U8RangeCheck(580, 581), Op::Mul(582, 582), Op::AssertEq(vec![583], vec![582], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(189, 578), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::Add(586, 589), Op::Add(588, 591), Op::Add(590, 585), Op::Add(584, 587), Op::UnconstrainedU32Add3(vec![565, 566, 567, 568], vec![592, 593, 594, 595], vec![124, 125, 126, 127]), Op::U8RangeCheck(596, 597), Op::U8RangeCheck(598, 599), Op::Sub(600, 133), Op::Sub(600, 135), Op::Mul(601, 602), Op::Mul(600, 603), Op::AssertEq(vec![604], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(576, 596), Op::U8Xor(577, 597), Op::U8Xor(574, 598), Op::U8Xor(575, 599), Op::UnconstrainedU32Add(vec![578, 579, 580, 581], vec![606, 607, 608, 605]), Op::U8RangeCheck(609, 610), Op::U8RangeCheck(611, 612), Op::Mul(613, 613), Op::AssertEq(vec![614], vec![613], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(592, 609), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::Add(615, 618), Op::Add(617, 620), Op::Add(619, 622), Op::Add(621, 616)], ctrl: Ctrl::Return(0, vec![410, 411, 412, 413, 472, 473, 474, 475, 534, 535, 536, 537, 596, 597, 598, 599, 623, 624, 625, 626, 437, 438, 439, 440, 499, 500, 501, 502, 561, 562, 563, 564, 547, 548, 549, 550, 609, 610, 611, 612, 423, 424, 425, 426, 485, 486, 487, 488, 482, 483, 484, 481, 544, 545, 546, 543, 606, 607, 608, 605, 420, 421, 422, 419, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]) }, layout: FunctionLayout { input_size: 128, selectors: 1, auxiliaries: 369, lookups: 193 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_82() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![121, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 106, 107, 108, 109, 110, 111, 106, 112, 113, 114, 115, 116, 117, 118, 119, 120, 96, 97, 98, 99, 100, 101, 102, 103, 104, 121, 121, 121, 105, 121, 121, 121, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], 32, false)], ctrl: Ctrl::Return(0, vec![122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153]) }, layout: FunctionLayout { input_size: 106, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_83() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(83, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_84() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_85() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_86() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6)], ctrl: Ctrl::Return(0, vec![7, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_87() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7, 1, 3, 8, 8, 8, 8, 8, 8, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_88() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Call(84, vec![4], 2, false), Op::Call(84, vec![6], 2, false), Op::Const(G::from_u64(256)), Op::Mul(9, 3), Op::Const(G::from_u64(65536)), Op::Mul(11, 5), Op::Const(G::from_u64(16777216)), Op::Mul(13, 7), Op::Add(12, 14), Op::Add(10, 15), Op::Add(1, 16), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17, 1, 3, 5, 7, 18, 18, 18, 18, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_89() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Call(84, vec![4], 2, false), Op::Call(84, vec![6], 2, false), Op::Call(84, vec![8], 2, false), Op::Call(84, vec![10], 2, false), Op::Call(84, vec![12], 2, false), Op::Call(84, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_90() -> Function { + Function { body: Block { ops: vec![Op::Call(89, vec![0], 9, false), Op::Const(G::from_u64(256)), Op::Mul(10, 2), Op::Const(G::from_u64(65536)), Op::Mul(12, 3), Op::Const(G::from_u64(16777216)), Op::Mul(14, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 8), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(1, 29)], ctrl: Ctrl::Return(0, vec![30, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 10, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_91() -> Function { + Function { body: Block { ops: vec![Op::Call(89, vec![0], 9, false), Op::Call(89, vec![9], 9, false), Op::Call(89, vec![18], 9, false), Op::Call(89, vec![27], 9, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_92() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 9, false), Op::Call(89, vec![10], 9, false), Op::Call(89, vec![19], 9, false), Op::Call(89, vec![28], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(92, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_93() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3, 3, 3, 3])], ctrl: Ctrl::Return(0, vec![4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(85, vec![0], 2, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(90, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(2, vec![13, 11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(85, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 13, 5, 12, 12, 10])], ctrl: Ctrl::Return(3, vec![14, 11]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(93, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(4, vec![12, 9]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(93, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(5, vec![12, 9]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(93, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(5)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(6, vec![12, 9]) }), (G::from_u64(6), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(86, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(93, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(6)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(7, vec![18, 15]) }), (G::from_u64(7), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(86, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(93, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(7)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(8, vec![18, 15]) }), (G::from_u64(8), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(86, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(93, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(9, vec![18, 15]) }), (G::from_u64(9), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 8), Op::Add(2, 8), Op::Call(93, vec![6, 9, 10], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(9)), Op::Store(vec![13, 14, 5, 13, 13, 11])], ctrl: Ctrl::Return(10, vec![15, 12]) }), (G::from_u64(10), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 12, 5, 10])], ctrl: Ctrl::Return(11, vec![13, 11]) }), (G::from_u64(11), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 7, 5, 10])], ctrl: Ctrl::Return(12, vec![13, 11]) }), (G::from_u64(12), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 12, 5, 10])], ctrl: Ctrl::Return(13, vec![13, 11]) }), (G::from_u64(13), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 7, 5, 10])], ctrl: Ctrl::Return(14, vec![13, 11]) }), (G::from_u64(14), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 12, 5, 10])], ctrl: Ctrl::Return(15, vec![14, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 7, 5, 10])], ctrl: Ctrl::Return(16, vec![14, 11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_94() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(94, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_95() -> Function { + Function { body: Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Call(86, vec![2], 2, false), Op::Call(94, vec![4, 3], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_96() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Call(86, vec![3], 2, false), Op::Call(94, vec![5, 4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(96, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 2, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_97() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(2, 3), Op::Call(97, vec![4, 5, 2], 1, false), Op::Add(3, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(1, 3), Op::Call(97, vec![4, 5, 2], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_98() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![10], 10, false), Op::Call(88, vec![20], 10, false), Op::Call(87, vec![30], 10, false), Op::Call(85, vec![40], 2, false), Op::Call(86, vec![42], 2, false), Op::Const(G::from_u64(0)), Op::Call(93, vec![44, 43, 45], 2, false), Op::Call(86, vec![47], 2, false), Op::Call(94, vec![49, 48], 2, false), Op::Call(86, vec![51], 2, false), Op::Call(96, vec![53, 52], 2, false), Op::Call(97, vec![52, 45, 41], 1, false), Op::EqZero(56), Op::Add(56, 57), Op::Add(58, 58), Op::Add(48, 59), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(61, 62), Op::U8RangeCheck(63, 64), Op::U8RangeCheck(65, 66), Op::U8RangeCheck(67, 68), Op::Const(G::from_u64(256)), Op::Mul(69, 62), Op::Const(G::from_u64(65536)), Op::Mul(71, 63), Op::Const(G::from_u64(16777216)), Op::Mul(73, 64), Op::Const(G::from_u64(4294967296)), Op::Mul(75, 65), Op::Const(G::from_u64(1099511627776)), Op::Mul(77, 66), Op::Const(G::from_u64(281474976710656)), Op::Mul(79, 67), Op::Const(G::from_u64(72057594037927936)), Op::Mul(81, 68), Op::Add(80, 82), Op::Add(78, 83), Op::Add(76, 84), Op::Add(74, 85), Op::Add(72, 86), Op::Add(70, 87), Op::Add(61, 88), Op::AssertEq(vec![89], vec![60], None), Op::Const(G::from_u64(1020)), Op::Sub(68, 90), Op::Add(67, 91), Op::Add(66, 92), Op::Add(65, 93), Op::EqZero(94), Op::Add(63, 64), Op::Add(62, 96), Op::Add(61, 97), Op::EqZero(98), Op::Const(G::from_u64(1)), Op::Sub(100, 99), Op::Mul(95, 101), Op::Sub(100, 102), Op::AssertEq(vec![103], vec![100], None), Op::UnconstrainedGToBytes(59), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 107), Op::U8RangeCheck(108, 109), Op::U8RangeCheck(110, 111), Op::Mul(69, 105), Op::Mul(71, 106), Op::Mul(73, 107), Op::Mul(75, 108), Op::Mul(77, 109), Op::Mul(79, 110), Op::Mul(81, 111), Op::Add(117, 118), Op::Add(116, 119), Op::Add(115, 120), Op::Add(114, 121), Op::Add(113, 122), Op::Add(112, 123), Op::Add(104, 124), Op::AssertEq(vec![125], vec![59], None), Op::Sub(111, 90), Op::Add(110, 126), Op::Add(109, 127), Op::Add(108, 128), Op::EqZero(129), Op::Add(106, 107), Op::Add(105, 131), Op::Add(104, 132), Op::EqZero(133), Op::Sub(100, 134), Op::Mul(130, 135), Op::Sub(100, 136), Op::AssertEq(vec![137], vec![100], None), Op::UnconstrainedGToBytes(41), Op::U8RangeCheck(138, 139), Op::U8RangeCheck(140, 141), Op::U8RangeCheck(142, 143), Op::U8RangeCheck(144, 145), Op::Mul(69, 139), Op::Mul(71, 140), Op::Mul(73, 141), Op::Mul(75, 142), Op::Mul(77, 143), Op::Mul(79, 144), Op::Mul(81, 145), Op::Add(151, 152), Op::Add(150, 153), Op::Add(149, 154), Op::Add(148, 155), Op::Add(147, 156), Op::Add(146, 157), Op::Add(138, 158), Op::AssertEq(vec![159], vec![41], None), Op::Sub(145, 90), Op::Add(144, 160), Op::Add(143, 161), Op::Add(142, 162), Op::EqZero(163), Op::Add(140, 141), Op::Add(139, 165), Op::Add(138, 166), Op::EqZero(167), Op::Sub(100, 168), Op::Mul(164, 169), Op::Sub(100, 170), Op::AssertEq(vec![171], vec![100], None)], ctrl: Ctrl::Return(0, vec![46, 43, 50, 31, 54, 41, 1, 11, 59, 61, 62, 63, 64, 65, 66, 67, 68, 32, 33, 34, 35, 36, 37, 38, 39, 22, 23, 24, 25, 26, 27, 28, 29, 12, 13, 14, 15, 16, 17, 18, 19, 2, 3, 4, 5, 6, 7, 8, 9, 104, 105, 106, 107, 108, 109, 110, 111, 138, 139, 140, 141, 142, 143, 144, 145, 55]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 97, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_99() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![57, 48, 49, 50, 51, 52, 53, 54, 55, 56]), Op::Store(vec![57, 40, 41, 42, 43, 44, 45, 46, 47, 58]), Op::Store(vec![57, 32, 33, 34, 35, 36, 37, 38, 39, 59]), Op::Store(vec![57, 24, 25, 26, 27, 28, 29, 30, 31, 60]), Op::Store(vec![57, 16, 17, 18, 19, 20, 21, 22, 23, 61]), Op::Store(vec![57, 8, 9, 10, 11, 12, 13, 14, 15, 62]), Op::Store(vec![57, 0, 1, 2, 3, 4, 5, 6, 7, 63])], ctrl: Ctrl::Return(0, vec![64]) }, layout: FunctionLayout { input_size: 57, selectors: 1, auxiliaries: 8, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_100() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![11], 10, false), Op::Call(88, vec![21], 10, false), Op::Call(87, vec![31], 10, false), Op::Call(85, vec![41], 2, false), Op::Call(86, vec![43], 2, false), Op::Const(G::from_u64(0)), Op::Call(93, vec![45, 44, 46], 2, false), Op::Call(86, vec![48], 2, false), Op::Call(94, vec![50, 49], 2, false), Op::Call(86, vec![52], 2, false), Op::Call(96, vec![54, 53], 2, false), Op::Call(97, vec![53, 46, 42], 1, false), Op::EqZero(57), Op::Add(57, 58), Op::Add(59, 59), Op::Add(49, 60), Op::UnconstrainedGToBytes(61), Op::U8RangeCheck(62, 63), Op::U8RangeCheck(64, 65), Op::U8RangeCheck(66, 67), Op::U8RangeCheck(68, 69), Op::Const(G::from_u64(256)), Op::Mul(70, 63), Op::Const(G::from_u64(65536)), Op::Mul(72, 64), Op::Const(G::from_u64(16777216)), Op::Mul(74, 65), Op::Const(G::from_u64(4294967296)), Op::Mul(76, 66), Op::Const(G::from_u64(1099511627776)), Op::Mul(78, 67), Op::Const(G::from_u64(281474976710656)), Op::Mul(80, 68), Op::Const(G::from_u64(72057594037927936)), Op::Mul(82, 69), Op::Add(81, 83), Op::Add(79, 84), Op::Add(77, 85), Op::Add(75, 86), Op::Add(73, 87), Op::Add(71, 88), Op::Add(62, 89), Op::AssertEq(vec![90], vec![61], None), Op::Const(G::from_u64(1020)), Op::Sub(69, 91), Op::Add(68, 92), Op::Add(67, 93), Op::Add(66, 94), Op::EqZero(95), Op::Add(64, 65), Op::Add(63, 97), Op::Add(62, 98), Op::EqZero(99), Op::Const(G::from_u64(1)), Op::Sub(101, 100), Op::Mul(96, 102), Op::Sub(101, 103), Op::AssertEq(vec![104], vec![101], None), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(105, 106), Op::U8RangeCheck(107, 108), Op::U8RangeCheck(109, 110), Op::U8RangeCheck(111, 112), Op::Mul(70, 106), Op::Mul(72, 107), Op::Mul(74, 108), Op::Mul(76, 109), Op::Mul(78, 110), Op::Mul(80, 111), Op::Mul(82, 112), Op::Add(118, 119), Op::Add(117, 120), Op::Add(116, 121), Op::Add(115, 122), Op::Add(114, 123), Op::Add(113, 124), Op::Add(105, 125), Op::AssertEq(vec![126], vec![60], None), Op::Sub(112, 91), Op::Add(111, 127), Op::Add(110, 128), Op::Add(109, 129), Op::EqZero(130), Op::Add(107, 108), Op::Add(106, 132), Op::Add(105, 133), Op::EqZero(134), Op::Sub(101, 135), Op::Mul(131, 136), Op::Sub(101, 137), Op::AssertEq(vec![138], vec![101], None), Op::UnconstrainedGToBytes(42), Op::U8RangeCheck(139, 140), Op::U8RangeCheck(141, 142), Op::U8RangeCheck(143, 144), Op::U8RangeCheck(145, 146), Op::Mul(70, 140), Op::Mul(72, 141), Op::Mul(74, 142), Op::Mul(76, 143), Op::Mul(78, 144), Op::Mul(80, 145), Op::Mul(82, 146), Op::Add(152, 153), Op::Add(151, 154), Op::Add(150, 155), Op::Add(149, 156), Op::Add(148, 157), Op::Add(147, 158), Op::Add(139, 159), Op::AssertEq(vec![160], vec![42], None), Op::Sub(146, 91), Op::Add(145, 161), Op::Add(144, 162), Op::Add(143, 163), Op::EqZero(164), Op::Add(141, 142), Op::Add(140, 166), Op::Add(139, 167), Op::EqZero(168), Op::Sub(101, 169), Op::Mul(165, 170), Op::Sub(101, 171), Op::AssertEq(vec![172], vec![101], None), Op::Sub(1, 101), Op::Call(100, vec![56, 173], 3, false), Op::Store(vec![46, 47, 44, 51, 32, 55, 42, 2, 12, 60, 174]), Op::Store(vec![46, 139, 140, 141, 142, 143, 144, 145, 146, 175]), Op::Store(vec![46, 105, 106, 107, 108, 109, 110, 111, 112, 178]), Op::Store(vec![46, 3, 4, 5, 6, 7, 8, 9, 10, 179]), Op::Store(vec![46, 13, 14, 15, 16, 17, 18, 19, 20, 180]), Op::Store(vec![46, 23, 24, 25, 26, 27, 28, 29, 30, 181]), Op::Store(vec![46, 33, 34, 35, 36, 37, 38, 39, 40, 182]), Op::Store(vec![46, 62, 63, 64, 65, 66, 67, 68, 69, 183])], ctrl: Ctrl::Return(1, vec![177, 184, 176]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 109, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_101() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![2], 2, false), Op::Call(92, vec![4, 3], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7, 5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_102() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(102, vec![3, 5], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(65535), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 9, 2, 6])], ctrl: Ctrl::Return(2, vec![10, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_103() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![10], 10, false), Op::Call(87, vec![20], 10, false), Op::Call(87, vec![30], 10, false), Op::Call(87, vec![40], 10, false), Op::Call(87, vec![50], 10, false), Op::Call(87, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79])], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 80, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 79, lookups: 16 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_104() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![10], 10, false), Op::Call(87, vec![20], 10, false), Op::Call(87, vec![30], 10, false), Op::Call(87, vec![40], 10, false), Op::Call(87, vec![50], 10, false), Op::Call(87, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79]), Op::Call(87, vec![70], 10, false), Op::Call(100, vec![90, 81], 3, false), Op::Call(101, vec![93], 3, false), Op::Call(102, vec![96, 81], 2, false), Op::Store(vec![71, 82, 83, 84, 85, 86, 87, 88, 89, 92]), Op::Call(251, vec![80, 99], 1, false)], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 100, 91, 94, 95, 97, 98]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 99, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_105() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 4]), Op::Store(vec![5, 2, 6]), Op::Store(vec![5, 1, 7]), Op::Store(vec![5, 0, 8])], ctrl: Ctrl::Return(0, vec![9]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_106() -> Function { + Function { body: Block { ops: vec![Op::Call(105, vec![28, 29, 30, 31, 32], 1, false), Op::Call(105, vec![24, 25, 26, 27, 33], 1, false), Op::Call(105, vec![20, 21, 22, 23, 34], 1, false), Op::Call(105, vec![16, 17, 18, 19, 35], 1, false), Op::Call(105, vec![12, 13, 14, 15, 36], 1, false), Op::Call(105, vec![8, 9, 10, 11, 37], 1, false), Op::Call(105, vec![4, 5, 6, 7, 38], 1, false), Op::Call(105, vec![0, 1, 2, 3, 39], 1, false)], ctrl: Ctrl::Return(0, vec![40]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_107() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_108() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(11)), Op::Call(83, vec![97, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 97, 97, 97, 97, 97, 97, 97, 97, 98, 97, 97, 97, 99, 97, 97, 97, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96], 32, false), Op::Store(vec![100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131])], ctrl: Ctrl::Return(0, vec![132]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 98, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_109() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(108, vec![1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(108, vec![2, 1], 1, false)], ctrl: Ctrl::Return(1, vec![3]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_110() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1), Op::EqZero(5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(110, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_111() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Sub(7, 2), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(111, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(111, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(111, vec![5, 8, 2], 1, false), Op::Store(vec![21, 4, 22])], ctrl: Ctrl::Return(3, vec![23]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_112() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(2, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(112, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(112, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(112, vec![5, 8, 2], 1, false), Op::Store(vec![20, 4, 21])], ctrl: Ctrl::Return(3, vec![22]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 27, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_113() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(12, 4), Op::Const(G::from_u64(65536)), Op::Mul(14, 5), Op::Const(G::from_u64(16777216)), Op::Mul(16, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 10), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(3, 31), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(33, 34), Op::U8RangeCheck(35, 36), Op::U8RangeCheck(37, 38), Op::U8RangeCheck(39, 40), Op::Mul(12, 34), Op::Mul(14, 35), Op::Mul(16, 36), Op::Mul(18, 37), Op::Mul(20, 38), Op::Mul(22, 39), Op::Mul(24, 40), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(33, 53), Op::AssertEq(vec![54], vec![32], None), Op::Const(G::from_u64(1020)), Op::Sub(40, 55), Op::Add(39, 56), Op::Add(38, 57), Op::Add(37, 58), Op::EqZero(59), Op::Add(35, 36), Op::Add(34, 61), Op::Add(33, 62), Op::EqZero(63), Op::Const(G::from_u64(1)), Op::Sub(65, 64), Op::Mul(60, 66), Op::Sub(65, 67), Op::AssertEq(vec![68], vec![65], None)], ctrl: Ctrl::Return(0, vec![33, 34, 35, 36, 37, 38, 39, 40, 11, 1, 65]) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![15, 15, 15, 15, 15, 15, 15, 15, 0, 1, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(113, vec![13, 14], 11, false)], ctrl: Ctrl::Return(2, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_114() -> Function { + Function { body: Block { ops: vec![Op::Call(113, vec![0, 1], 11, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(24, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![57, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, 70, 71, 72, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 58, 59, 60, 61, 62, 63, 64, 65, 57, 57, 57, 57, 66, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57], 32, false), Op::Store(vec![57, 5, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113])], ctrl: Ctrl::Return(0, vec![114]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(113, vec![14, 15], 11, false), Op::Call(113, vec![25, 26], 11, false), Op::Call(113, vec![36, 37], 11, false), Op::Call(113, vec![47, 48], 11, false), Op::Call(113, vec![58, 59], 11, false), Op::Call(113, vec![69, 70], 11, false), Op::Call(113, vec![80, 81], 11, false), Op::Const(G::from_u64(8)), Op::Add(82, 93), Op::Add(71, 95), Op::Add(60, 96), Op::Add(49, 97), Op::Add(38, 98), Op::Add(27, 99), Op::Add(16, 100), Op::Mul(94, 101), Op::Load(10, 91)], ctrl: Ctrl::MatchContinue(103, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(9, vec![116]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![116]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(11, vec![113]) })), 1, 4, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(15)), Op::Sub(2, 114), Op::EqZero(115), Op::EqZero(2), Op::Mul(113, 116), Op::Sub(116, 118), Op::Add(113, 119), Op::Load(8, 3), Op::Call(2, vec![121, 122, 123, 124, 125, 126, 127, 128], 1, false), Op::Mul(113, 129), Op::Const(G::from_u64(2)), Op::Mul(131, 120), Op::Const(G::from_u64(8)), Op::Mul(133, 130), Op::Add(132, 134), Op::Add(117, 135), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![184, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 169, 175, 176, 177, 178, 179, 180, 181, 182, 183, 121, 122, 123, 124, 125, 126, 127, 128, 102, 184, 184, 184, 136, 184, 184, 184, 6, 7, 8, 9, 10, 11, 12, 13, 17, 18, 19, 20, 21, 22, 23, 24, 28, 29, 30, 31, 32, 33, 34, 35, 39, 40, 41, 42, 43, 44, 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 61, 62, 63, 64, 65, 66, 67, 68, 72, 73, 74, 75, 76, 77, 78, 79, 83, 84, 85, 86, 87, 88, 89, 90], 32, false)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![217, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216])], ctrl: Ctrl::Return(12, vec![218]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(116, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Call(11, vec![249, 250, 251, 252, 253, 254, 255, 256], 8, false), Op::Store(vec![257, 258, 259, 260, 261, 262, 263, 264]), Op::Store(vec![217, 218, 219, 220, 221, 222, 217, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247]), Op::Store(vec![248, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(114, vec![91, 92, 248, 265, 266, 267], 1, false)], ctrl: Ctrl::Return(13, vec![268]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 217), Op::Store(vec![185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(114, vec![91, 92, 218, 3, 219, 5], 1, false)], ctrl: Ctrl::Return(14, vec![220]) }))) }))) })) }))) }, layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_115() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(114, vec![33, 0, 34, 35, 36, 37], 1, false), Op::Call(74, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_116() -> Function { + Function { body: Block { ops: vec![Op::Call(111, vec![0, 1, 2], 1, false), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Const(G::from_u64(0)), Op::Store(vec![37, 37, 37, 37, 37, 37, 37, 37]), Op::Store(vec![4, 5, 6, 7, 8, 9, 4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Call(114, vec![36, 3, 37, 38, 39, 40], 1, false), Op::Call(74, vec![41], 32, false), Op::Store(vec![42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73])], ctrl: Ctrl::Return(0, vec![74]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 40, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_117() -> Function { + Function { body: Block { ops: vec![Op::Call(110, vec![1, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(116, vec![0, 1, 2], 1, false), Op::Call(108, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_118() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(118, vec![3], 1, false), Op::Mul(4, 5), Op::Add(2, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_119() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(0, vec![3, 9], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(119, vec![7, 1], 1, false), Op::Store(vec![15, 3, 4, 5, 6, 16])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 9), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::AssertEq(vec![6], vec![12], None), Op::AssertEq(vec![5], vec![11], None), Op::Const(G::from_u64(0)), Op::Call(119, vec![7, 13], 1, false), Op::Store(vec![17, 3, 4, 5, 6, 18])], ctrl: Ctrl::Return(3, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(119, vec![0, 13], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 18])], ctrl: Ctrl::Return(4, vec![19]) }))) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_120() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14, 14, 14, 14]), Op::Store(vec![13, 2, 3, 4, 5, 15])], ctrl: Ctrl::Return(1, vec![16, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(120, vec![12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 13]), Op::Store(vec![15, 8, 9, 10, 11, 14])], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 17, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_121() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(120, vec![0], 2, false), Op::Call(121, vec![13], 1, false), Op::Call(121, vec![14], 1, false), Op::Call(119, vec![15, 16], 1, false)], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 18, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_122() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(241, vec![1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], None), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(116, vec![8, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(118, vec![5], 1, false), Op::Call(122, vec![6, 9, 2, 3], 1, false), Op::Store(vec![11, 12, 5, 8, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 11, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_123() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(118, vec![12], 1, false), Op::Load(6, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(118, vec![22], 1, false), Op::Sub(13, 23), Op::EqZero(24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Call(112, vec![7, 2, 3], 1, false), Op::Call(112, vec![17, 2, 3], 1, false), Op::AssertEq(vec![26], vec![27], None), Op::Call(108, vec![8, 18], 1, false), Op::Call(117, vec![7, 2, 3, 28], 1, false), Op::Call(123, vec![19, 1, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![32, 13, 12, 7, 29, 30])], ctrl: Ctrl::Return(1, vec![33, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Call(109, vec![11, 8, 27], 1, false), Op::Call(117, vec![7, 2, 3, 29], 1, false), Op::Call(123, vec![9, 28, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![33, 13, 12, 7, 30, 31])], ctrl: Ctrl::Return(2, vec![34, 32]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(109, vec![11, 8, 21], 1, false), Op::Call(117, vec![7, 2, 3, 23], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26, 26, 26, 26]), Op::Store(vec![25, 13, 12, 7, 24, 27])], ctrl: Ctrl::Return(3, vec![28, 22]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 32, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_124() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 4), Op::Call(123, vec![0, 1, 2, 5], 2, false), Op::Call(124, vec![6, 7, 2, 5], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_125() -> Function { + Function { body: Block { ops: vec![Op::Call(241, vec![1], 1, false), Op::Call(241, vec![3], 1, false), Op::Sub(6, 7), Op::EqZero(8), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], None), Op::Call(122, vec![3, 1, 2, 5], 1, false), Op::Call(121, vec![11], 1, false), Op::Call(124, vec![12, 4, 2, 5], 2, false), Op::Call(241, vec![14], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![15], vec![16], None), Op::Load(6, 13)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Call(244, vec![22], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![0, 18], 1, false), Op::Sub(25, 21), Op::EqZero(26)], ctrl: Ctrl::Return(0, vec![27]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 20, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_126() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 1]), Op::Call(126, vec![4, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_127() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(0, 0), Op::Call(127, vec![5, 4], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 6)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_128() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 8), Op::Call(183, vec![9], 1, false), Op::Store(vec![8, 8, 8]), Op::Call(126, vec![0, 11], 1, false), Op::Call(127, vec![10, 12], 1, false), Op::Add(13, 13), Op::Add(4, 6), Op::Add(5, 7), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Mul(17, 17), Op::Const(G::from_u64(7)), Op::Mul(18, 18), Op::Mul(20, 21), Op::Sub(19, 22), Op::UnconstrainedGInverse(23), Op::Mul(23, 24), Op::Sub(25, 8), Op::Mul(23, 26), Op::AssertEq(vec![27], vec![18], None), Op::Mul(24, 26), Op::AssertEq(vec![28], vec![18], None), Op::Mul(17, 24), Op::Sub(18, 18), Op::Mul(30, 24), Op::Mul(15, 29), Op::Mul(16, 31), Op::Mul(20, 33), Op::Add(32, 34), Op::Mul(15, 31), Op::Mul(16, 29), Op::Add(36, 37), Op::Sub(4, 6), Op::Sub(5, 7), Op::Mul(14, 14), Op::Sub(41, 22), Op::UnconstrainedGInverse(42), Op::Mul(42, 43), Op::Sub(44, 8), Op::Mul(42, 45), Op::AssertEq(vec![46], vec![18], None), Op::Mul(43, 45), Op::AssertEq(vec![47], vec![18], None), Op::Mul(14, 43), Op::Mul(30, 43), Op::Mul(39, 48), Op::Mul(40, 49), Op::Mul(20, 51), Op::Add(50, 52), Op::Mul(39, 49), Op::Mul(40, 48), Op::Add(54, 55), Op::Mul(2, 53), Op::Mul(3, 56), Op::Mul(20, 58), Op::Add(57, 59), Op::Mul(2, 56), Op::Mul(3, 53), Op::Add(61, 62), Op::Add(35, 60), Op::Add(38, 63)], ctrl: Ctrl::Return(0, vec![64, 65]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 25, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_129() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(7)), Op::Call(183, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(126, vec![0, 5], 1, false), Op::Call(127, vec![3, 6], 1, false), Op::Mul(2, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_130() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(22, 10), Op::Const(G::from_u64(65536)), Op::Mul(24, 11), Op::Const(G::from_u64(16777216)), Op::Mul(26, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(28, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(30, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(32, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(34, 16), Op::Add(33, 35), Op::Add(31, 36), Op::Add(29, 37), Op::Add(27, 38), Op::Add(25, 39), Op::Add(23, 40), Op::Add(9, 41), Op::Const(G::from_u64(0)), Op::Sub(19, 42), Op::Sub(20, 43), Op::Mul(6, 44), Op::Const(G::from_u64(7)), Op::Mul(7, 45), Op::Mul(47, 48), Op::Add(46, 49), Op::Mul(6, 45), Op::Mul(7, 44), Op::Add(51, 52), Op::Add(4, 50), Op::Add(5, 53), Op::Mul(6, 2), Op::Mul(7, 3), Op::Mul(47, 57), Op::Add(56, 58), Op::Mul(6, 3), Op::Mul(7, 2), Op::Add(60, 61), Op::Call(130, vec![17, 21, 2, 3, 54, 55, 59, 62], 4, false)], ctrl: Ctrl::Return(1, vec![63, 64, 65, 66]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_131() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::U8RangeCheck(12, 13), Op::Const(G::from_u64(256)), Op::Mul(14, 7), Op::Const(G::from_u64(65536)), Op::Mul(16, 8), Op::Const(G::from_u64(16777216)), Op::Mul(18, 9), Op::Const(G::from_u64(4294967296)), Op::Mul(20, 10), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 11), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 12), Op::Const(G::from_u64(72057594037927936)), Op::Mul(26, 13), Op::Add(25, 27), Op::Add(23, 28), Op::Add(21, 29), Op::Add(19, 30), Op::Add(17, 31), Op::Add(15, 32), Op::Add(6, 33), Op::AssertEq(vec![34], vec![3], None), Op::Const(G::from_u64(1020)), Op::Sub(13, 35), Op::Add(12, 36), Op::Add(11, 37), Op::Add(10, 38), Op::EqZero(39), Op::Add(8, 9), Op::Add(7, 41), Op::Add(6, 42), Op::EqZero(43), Op::Const(G::from_u64(1)), Op::Sub(45, 44), Op::Mul(40, 46), Op::Sub(45, 47), Op::AssertEq(vec![48], vec![45], None), Op::UnconstrainedGToBytes(4), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::U8RangeCheck(55, 56), Op::Mul(14, 50), Op::Mul(16, 51), Op::Mul(18, 52), Op::Mul(20, 53), Op::Mul(22, 54), Op::Mul(24, 55), Op::Mul(26, 56), Op::Add(62, 63), Op::Add(61, 64), Op::Add(60, 65), Op::Add(59, 66), Op::Add(58, 67), Op::Add(57, 68), Op::Add(49, 69), Op::AssertEq(vec![70], vec![4], None), Op::Sub(56, 35), Op::Add(55, 71), Op::Add(54, 72), Op::Add(53, 73), Op::EqZero(74), Op::Add(51, 52), Op::Add(50, 76), Op::Add(49, 77), Op::EqZero(78), Op::Sub(45, 79), Op::Mul(75, 80), Op::Sub(45, 81), Op::AssertEq(vec![82], vec![45], None), Op::Call(131, vec![5, 1], 1, false), Op::Call(168, vec![49, 50, 51, 52, 53, 54, 55, 56, 83], 1, false), Op::Call(168, vec![6, 7, 8, 9, 10, 11, 12, 13, 84], 1, false)], ctrl: Ctrl::Return(1, vec![85]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 34, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_132() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(132, vec![4, 1], 1, false), Op::Call(131, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_133() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(133, vec![4, 1], 1, false), Op::Call(132, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_134() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(133, vec![1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_135() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(177, vec![0, 5, 6, 6, 6, 6, 6, 6, 6], 1, false), Op::Call(135, vec![7, 4], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_136() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![0, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Call(176, vec![10, 12, 9], 3, false), Op::Call(118, vec![13], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![14, 15]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_137() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(178, vec![0, 5], 1, false), Op::Call(136, vec![17, 8, 9, 10, 11, 12, 13, 14, 15, 3], 2, false), Op::Call(174, vec![18, 19], 18, false), Op::Call(137, vec![36, 6, 16, 3], 2, false), Op::Const(G::from_u64(256)), Op::Mul(40, 21), Op::Const(G::from_u64(65536)), Op::Mul(42, 22), Op::Const(G::from_u64(16777216)), Op::Mul(44, 23), Op::Const(G::from_u64(4294967296)), Op::Mul(46, 24), Op::Const(G::from_u64(1099511627776)), Op::Mul(48, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(50, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(52, 27), Op::Add(51, 53), Op::Add(49, 54), Op::Add(47, 55), Op::Add(45, 56), Op::Add(43, 57), Op::Add(41, 58), Op::Add(20, 59), Op::Const(G::from_u64(0)), Op::Mul(40, 29), Op::Mul(42, 30), Op::Mul(44, 31), Op::Mul(46, 32), Op::Mul(48, 33), Op::Mul(50, 34), Op::Mul(52, 35), Op::Add(67, 68), Op::Add(66, 69), Op::Add(65, 70), Op::Add(64, 71), Op::Add(63, 72), Op::Add(62, 73), Op::Add(28, 74), Op::Store(vec![61, 60, 75, 38])], ctrl: Ctrl::Return(1, vec![76, 39]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 38, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_138() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![0, 3], 1, false), Op::Sub(1, 4), Op::Add(5, 6), Op::EqZero(7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 9), Op::Add(3, 9), Op::Call(138, vec![0, 1, 10, 11, 4], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_139() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(138, vec![0, 1, 2, 4, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 6), Op::Call(139, vec![0, 1, 2, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(139, vec![0, 1, 2, 8], 1, false), Op::Store(vec![6, 3, 7, 6, 6, 6, 9])], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_140() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![16]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(9, 1), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(130, vec![2, 3, 6, 7, 17, 17, 10, 11], 4, false), Op::Mul(4, 18), Op::Const(G::from_u64(7)), Op::Mul(5, 19), Op::Mul(23, 24), Op::Add(22, 25), Op::Mul(4, 19), Op::Mul(5, 18), Op::Add(27, 28), Op::Add(12, 26), Op::Add(13, 29), Op::Store(vec![17, 9, 20, 21, 30, 31, 14])], ctrl: Ctrl::Return(1, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(140, vec![14, 1, 2, 3, 4, 5, 6, 7], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 13, 18])], ctrl: Ctrl::Return(2, vec![19]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_141() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 1), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(6, 11), Op::EqZero(12), Op::Sub(7, 11), Op::EqZero(14), Op::Mul(13, 15), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(141, vec![8, 1], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_142() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_143() -> Function { + Function { body: Block { ops: vec![Op::Call(246, vec![6], 1, false), Op::Call(242, vec![7], 1, false), Op::Sub(10, 11), Op::EqZero(12), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], None), Op::Sub(3, 1), Op::Call(253, vec![2, 15], 1, false), Op::Const(G::from_u64(7)), Op::Call(183, vec![1], 1, false), Op::Store(vec![14, 14, 14]), Op::Call(126, vec![16, 19], 1, false), Op::Call(127, vec![18, 20], 1, false), Op::Mul(17, 21), Op::Const(G::from_u64(0)), Op::Sub(4, 22), Op::Sub(5, 23), Op::Mul(24, 24), Op::Mul(25, 25), Op::Mul(17, 27), Op::Sub(26, 28), Op::UnconstrainedGInverse(29), Op::Mul(29, 30), Op::Sub(31, 14), Op::Mul(29, 32), Op::AssertEq(vec![33], vec![23], None), Op::Mul(30, 32), Op::AssertEq(vec![34], vec![23], None), Op::Mul(24, 30), Op::Sub(23, 25), Op::Mul(36, 30), Op::Call(140, vec![0, 1, 6, 7, 35, 37, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![38]) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_144() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![8, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(239, vec![8, 13], 1, false), Op::Call(183, vec![4], 1, false), Op::Mul(5, 15), Op::Const(G::from_u64(7)), Op::Mul(6, 11), Op::Mul(17, 18), Op::Add(16, 19), Op::Mul(5, 11), Op::Mul(6, 15), Op::Add(21, 22), Op::Call(143, vec![0, 3, 1, 2, 5, 6, 7, 12, 9, 10], 1, false), Op::Call(143, vec![24, 3, 1, 2, 20, 23, 7, 14, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![25]) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_145() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(239, vec![9, 4], 1, false), Op::Call(239, vec![10, 4], 1, false), Op::Call(144, vec![0, 1, 2, 14, 13, 7, 8, 15, 16, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 18), Op::Sub(5, 18), Op::Call(145, vec![17, 1, 2, 3, 19, 20, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![21]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_146() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(239, vec![9, 4], 1, false), Op::Call(239, vec![10, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![16, 17], 1, false), Op::Call(143, vec![0, 14, 1, 2, 7, 8, 15, 18, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 20), Op::Sub(5, 20), Op::Call(146, vec![19, 1, 2, 3, 21, 22, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![23]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 8, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_147() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(250, vec![8, 4], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 17), Op::Sub(5, 17), Op::Call(147, vec![0, 1, 2, 3, 18, 19, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![20]) }), (G::from_u64(1), Block { ops: vec![Op::Call(239, vec![7, 4], 1, false), Op::Add(17, 3), Op::Call(239, vec![11, 6], 1, false), Op::Call(239, vec![12, 6], 1, false), Op::Call(144, vec![0, 1, 2, 18, 17, 9, 10, 19, 20, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 22), Op::Sub(5, 22), Op::Add(6, 22), Op::Call(147, vec![21, 1, 2, 3, 23, 24, 25, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(2, vec![26]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_148() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(239, vec![1, 15], 1, false)], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![16], 1, false), Op::Call(241, vec![4], 1, false), Op::Sub(17, 18), Op::EqZero(19), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Const(G::from_u64(0)), Op::Call(151, vec![6, 10, 5, 7, 22], 1, false), Op::Call(150, vec![23], 1, false), Op::Call(147, vec![0, 8, 9, 10, 22, 7, 22, 6, 5, 11, 12, 16, 4, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_149() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![0, 3], 1, false), Op::Add(5, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Add(3, 7), Op::Call(149, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_150() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(150, vec![3], 1, false), Op::U32LessThan(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_151() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(250, vec![2, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Add(4, 7), Op::Call(151, vec![0, 1, 2, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![0, 4], 1, false), Op::Add(8, 1), Op::Const(G::from_u64(1)), Op::Sub(3, 10), Op::Add(4, 10), Op::Call(151, vec![0, 1, 2, 11, 12], 1, false), Op::Store(vec![7, 9, 13])], ctrl: Ctrl::Return(2, vec![14]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_152() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 1, 2]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_153() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Const(G::from_u64(256)), Op::Mul(12, 5), Op::Const(G::from_u64(65536)), Op::Mul(14, 6), Op::Const(G::from_u64(16777216)), Op::Mul(16, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 11), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(4, 31), Op::AssertEq(vec![32], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(11, 33), Op::Add(10, 34), Op::Add(9, 35), Op::Add(8, 36), Op::EqZero(37), Op::Add(6, 7), Op::Add(5, 39), Op::Add(4, 40), Op::EqZero(41), Op::Const(G::from_u64(1)), Op::Sub(43, 42), Op::Mul(38, 44), Op::Sub(43, 45), Op::AssertEq(vec![46], vec![43], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(47, 48), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::Mul(12, 48), Op::Mul(14, 49), Op::Mul(16, 50), Op::Mul(18, 51), Op::Mul(20, 52), Op::Mul(22, 53), Op::Mul(24, 54), Op::Add(60, 61), Op::Add(59, 62), Op::Add(58, 63), Op::Add(57, 64), Op::Add(56, 65), Op::Add(55, 66), Op::Add(47, 67), Op::AssertEq(vec![68], vec![1], None), Op::Sub(54, 33), Op::Add(53, 69), Op::Add(52, 70), Op::Add(51, 71), Op::EqZero(72), Op::Add(49, 50), Op::Add(48, 74), Op::Add(47, 75), Op::EqZero(76), Op::Sub(43, 77), Op::Mul(73, 78), Op::Sub(43, 79), Op::AssertEq(vec![80], vec![43], None), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(81, 82), Op::U8RangeCheck(83, 84), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::Mul(12, 82), Op::Mul(14, 83), Op::Mul(16, 84), Op::Mul(18, 85), Op::Mul(20, 86), Op::Mul(22, 87), Op::Mul(24, 88), Op::Add(94, 95), Op::Add(93, 96), Op::Add(92, 97), Op::Add(91, 98), Op::Add(90, 99), Op::Add(89, 100), Op::Add(81, 101), Op::AssertEq(vec![102], vec![2], None), Op::Sub(88, 33), Op::Add(87, 103), Op::Add(86, 104), Op::Add(85, 105), Op::EqZero(106), Op::Add(83, 84), Op::Add(82, 108), Op::Add(81, 109), Op::EqZero(110), Op::Sub(43, 111), Op::Mul(107, 112), Op::Sub(43, 113), Op::AssertEq(vec![114], vec![43], None), Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(115, 116), Op::U8RangeCheck(117, 118), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::Mul(12, 116), Op::Mul(14, 117), Op::Mul(16, 118), Op::Mul(18, 119), Op::Mul(20, 120), Op::Mul(22, 121), Op::Mul(24, 122), Op::Add(128, 129), Op::Add(127, 130), Op::Add(126, 131), Op::Add(125, 132), Op::Add(124, 133), Op::Add(123, 134), Op::Add(115, 135), Op::AssertEq(vec![136], vec![3], None), Op::Sub(122, 33), Op::Add(121, 137), Op::Add(120, 138), Op::Add(119, 139), Op::EqZero(140), Op::Add(117, 118), Op::Add(116, 142), Op::Add(115, 143), Op::EqZero(144), Op::Sub(43, 145), Op::Mul(141, 146), Op::Sub(43, 147), Op::AssertEq(vec![148], vec![43], None), Op::Const(G::from_u64(0)), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Store(vec![149, 115, 116, 117, 118, 119, 120, 121, 122, 150]), Op::Store(vec![149, 81, 82, 83, 84, 85, 86, 87, 88, 151]), Op::Store(vec![149, 47, 48, 49, 50, 51, 52, 53, 54, 152]), Op::Store(vec![149, 4, 5, 6, 7, 8, 9, 10, 11, 153])], ctrl: Ctrl::Return(0, vec![154]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 58, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_154() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(7, 2), Op::EqZero(13)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(182, vec![3, 4, 15], 2, false), Op::Mul(16, 10), Op::Const(G::from_u64(7)), Op::Mul(17, 11), Op::Mul(19, 20), Op::Add(18, 21), Op::Mul(16, 11), Op::Mul(17, 10), Op::Add(23, 24), Op::Add(0, 22), Op::Add(1, 25)], ctrl: Ctrl::Return(1, vec![26, 27, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 1, 5]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 16, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_155() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Sub(6, 8), Op::EqZero(13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], None), Op::Call(245, vec![7], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(0, vec![0, 1, 18]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(242, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Load(3, 5)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(6, 25), Op::Const(G::from_u64(0)), Op::Call(250, vec![11, 27], 2, false)], ctrl: Ctrl::MatchContinue(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![0, 1, 28, 29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![28, 29, 0, 1]) })), 4, 1, 0, Box::new(Block { ops: vec![Op::Call(128, vec![24, 26, 14, 15, 30, 31, 32, 33], 2, false), Op::Call(154, vec![34, 35, 26, 14, 15, 7], 3, false), Op::Call(155, vec![36, 37, 16, 19, 12, 24, 26, 38, 8], 3, false), Op::UnconstrainedGToBytes(30), Op::U8RangeCheck(42, 43), Op::U8RangeCheck(44, 45), Op::U8RangeCheck(46, 47), Op::U8RangeCheck(48, 49), Op::Const(G::from_u64(256)), Op::Mul(50, 43), Op::Const(G::from_u64(65536)), Op::Mul(52, 44), Op::Const(G::from_u64(16777216)), Op::Mul(54, 45), Op::Const(G::from_u64(4294967296)), Op::Mul(56, 46), Op::Const(G::from_u64(1099511627776)), Op::Mul(58, 47), Op::Const(G::from_u64(281474976710656)), Op::Mul(60, 48), Op::Const(G::from_u64(72057594037927936)), Op::Mul(62, 49), Op::Add(61, 63), Op::Add(59, 64), Op::Add(57, 65), Op::Add(55, 66), Op::Add(53, 67), Op::Add(51, 68), Op::Add(42, 69), Op::AssertEq(vec![70], vec![30], None), Op::Const(G::from_u64(1020)), Op::Sub(49, 71), Op::Add(48, 72), Op::Add(47, 73), Op::Add(46, 74), Op::EqZero(75), Op::Add(44, 45), Op::Add(43, 77), Op::Add(42, 78), Op::EqZero(79), Op::Const(G::from_u64(1)), Op::Sub(81, 80), Op::Mul(76, 82), Op::Sub(81, 83), Op::AssertEq(vec![84], vec![81], None), Op::UnconstrainedGToBytes(31), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::U8RangeCheck(89, 90), Op::U8RangeCheck(91, 92), Op::Mul(50, 86), Op::Mul(52, 87), Op::Mul(54, 88), Op::Mul(56, 89), Op::Mul(58, 90), Op::Mul(60, 91), Op::Mul(62, 92), Op::Add(98, 99), Op::Add(97, 100), Op::Add(96, 101), Op::Add(95, 102), Op::Add(94, 103), Op::Add(93, 104), Op::Add(85, 105), Op::AssertEq(vec![106], vec![31], None), Op::Sub(92, 71), Op::Add(91, 107), Op::Add(90, 108), Op::Add(89, 109), Op::EqZero(110), Op::Add(87, 88), Op::Add(86, 112), Op::Add(85, 113), Op::EqZero(114), Op::Sub(81, 115), Op::Mul(111, 116), Op::Sub(81, 117), Op::AssertEq(vec![118], vec![81], None), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::U8RangeCheck(123, 124), Op::U8RangeCheck(125, 126), Op::Mul(50, 120), Op::Mul(52, 121), Op::Mul(54, 122), Op::Mul(56, 123), Op::Mul(58, 124), Op::Mul(60, 125), Op::Mul(62, 126), Op::Add(132, 133), Op::Add(131, 134), Op::Add(130, 135), Op::Add(129, 136), Op::Add(128, 137), Op::Add(127, 138), Op::Add(119, 139), Op::AssertEq(vec![140], vec![32], None), Op::Sub(126, 71), Op::Add(125, 141), Op::Add(124, 142), Op::Add(123, 143), Op::EqZero(144), Op::Add(121, 122), Op::Add(120, 146), Op::Add(119, 147), Op::EqZero(148), Op::Sub(81, 149), Op::Mul(145, 150), Op::Sub(81, 151), Op::AssertEq(vec![152], vec![81], None), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(153, 154), Op::U8RangeCheck(155, 156), Op::U8RangeCheck(157, 158), Op::U8RangeCheck(159, 160), Op::Mul(50, 154), Op::Mul(52, 155), Op::Mul(54, 156), Op::Mul(56, 157), Op::Mul(58, 158), Op::Mul(60, 159), Op::Mul(62, 160), Op::Add(166, 167), Op::Add(165, 168), Op::Add(164, 169), Op::Add(163, 170), Op::Add(162, 171), Op::Add(161, 172), Op::Add(153, 173), Op::AssertEq(vec![174], vec![33], None), Op::Sub(160, 71), Op::Add(159, 175), Op::Add(158, 176), Op::Add(157, 177), Op::EqZero(178), Op::Add(155, 156), Op::Add(154, 180), Op::Add(153, 181), Op::EqZero(182), Op::Sub(81, 183), Op::Mul(179, 184), Op::Sub(81, 185), Op::AssertEq(vec![186], vec![81], None), Op::Const(G::from_u64(0)), Op::Store(vec![81, 81, 81, 81, 81, 81, 81, 81, 81, 81]), Op::Store(vec![187, 153, 154, 155, 156, 157, 158, 159, 160, 188]), Op::Store(vec![187, 119, 120, 121, 122, 123, 124, 125, 126, 189]), Op::Store(vec![187, 85, 86, 87, 88, 89, 90, 91, 92, 190]), Op::Store(vec![187, 42, 43, 44, 45, 46, 47, 48, 49, 191]), Op::Store(vec![187, 192, 41])], ctrl: Ctrl::Return(3, vec![39, 40, 193]) })) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 89, lookups: 32 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_156() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(242, vec![2], 1, false), Op::Sub(25, 24), Op::EqZero(26), Op::Const(G::from_u64(1)), Op::AssertEq(vec![27], vec![28], None), Op::Call(241, vec![1], 1, false), Op::Const(G::from_u64(3)), Op::Call(142, vec![8, 9], 1, false), Op::Add(30, 31), Op::Sub(29, 32), Op::EqZero(33), Op::AssertEq(vec![34], vec![28], None), Op::Call(139, vec![15, 19, 18, 20], 1, false), Op::Const(G::from_u64(0)), Op::Call(149, vec![15, 19, 18, 36], 1, false), Op::Call(239, vec![1, 36], 1, false)], ctrl: Ctrl::Match(38, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![38], 1, false), Op::Sub(39, 18), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::AssertEq(vec![41], vec![42], None), Op::Const(G::from_u64(0)), Op::Call(145, vec![35, 0, 20, 19, 43, 18, 15, 16, 17, 38, 5, 3, 4], 1, false), Op::Call(239, vec![1, 42], 1, false)], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![45], 1, false), Op::Sub(46, 18), Op::EqZero(47), Op::Const(G::from_u64(1)), Op::AssertEq(vec![48], vec![49], None), Op::Const(G::from_u64(0)), Op::Call(145, vec![44, 0, 20, 19, 50, 18, 15, 16, 17, 45, 6, 3, 4], 1, false), Op::Const(G::from_u64(2)), Op::Call(239, vec![1, 52], 1, false)], ctrl: Ctrl::Match(53, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![53], 1, false), Op::Sub(54, 18), Op::EqZero(55), Op::Const(G::from_u64(1)), Op::AssertEq(vec![56], vec![57], None), Op::Const(G::from_u64(0)), Op::Call(146, vec![51, 0, 20, 19, 58, 18, 15, 16, 17, 53, 7, 3, 4], 1, false), Op::Call(148, vec![59, 1, 13, 8, 9, 14, 15, 18, 0, 20, 19, 16, 17, 3, 4], 1, false), Op::Call(141, vec![60, 19], 1, false), Op::Load(7, 60)], ctrl: Ctrl::Match(62, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(63, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(63, 20), Op::EqZero(69), Op::Const(G::from_u64(1)), Op::AssertEq(vec![70], vec![71], None), Op::Call(155, vec![66, 67, 21, 22, 2, 0, 20, 68, 19], 3, false), Op::Const(G::from_u64(0)), Op::Call(250, vec![23, 75], 2, false), Op::Sub(76, 72), Op::EqZero(78), Op::Sub(77, 73), Op::EqZero(80), Op::Mul(79, 81), Op::AssertEq(vec![82], vec![71], None)], ctrl: Ctrl::Return(0, vec![74]) }))) })].into_iter().collect(), None) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 25, selectors: 1, auxiliaries: 46, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_157() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29])], ctrl: Ctrl::Return(0, vec![30]) }), (G::from_u64(0), Block { ops: vec![Op::Call(176, vec![0, 1, 20], 3, false), Op::Call(156, vec![29, 26, 27, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Const(G::from_u64(0)), Op::Call(157, vec![30, 31, 28, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Store(vec![33, 32, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 25, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_158() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![0, 1, 3], 3, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(158, vec![5, 6, 9, 3], 1, false), Op::Store(vec![7, 4, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_159() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![3, 1], 1, false), Op::Call(159, vec![5, 1], 1, false), Op::Store(vec![6, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_160() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![4, 1], 1, false), Op::Call(160, vec![6, 1], 1, false), Op::Store(vec![7, 3, 8, 9])], ctrl: Ctrl::Return(1, vec![10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_161() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(159, vec![0, 2], 1, false), Op::Call(160, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Sub(3, 7), Op::Call(161, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 5, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_162() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(149, vec![9, 11, 10, 13], 1, false), Op::Call(250, vec![0, 13], 2, false)], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(250, vec![0, 17], 2, false)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(250, vec![0, 20], 2, false)], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(125, vec![2, 15, 14, 1, 16, 12], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![23], vec![24], None), Op::Call(125, vec![3, 18, 14, 1, 19, 12], 1, false), Op::AssertEq(vec![25], vec![24], None), Op::Call(125, vec![4, 21, 14, 1, 22, 12], 1, false), Op::AssertEq(vec![26], vec![24], None)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(250, vec![0, 27], 2, false)], ctrl: Ctrl::Match(28, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(151, vec![9, 11, 8, 10, 30], 1, false), Op::Call(150, vec![31], 1, false), Op::Sub(12, 32), Op::Call(163, vec![1, 33], 1, false), Op::Call(125, vec![5, 28, 31, 34, 29, 32], 1, false)], ctrl: Ctrl::Return(1, vec![35]) }))) })].into_iter().collect(), None) }))) }))) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 17, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_163() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(253, vec![3, 1], 1, false), Op::Call(163, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_164() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![3, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![5, 6, 8]), Op::Call(164, vec![4, 1], 1, false), Op::Store(vec![5, 9, 10])], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_165() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(241, vec![1], 1, false), Op::EqZero(11)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![14], None), Op::Call(241, vec![8], 1, false), Op::Call(241, vec![3], 1, false), Op::AssertEq(vec![15], vec![16], None), Op::Call(163, vec![3, 14], 1, false), Op::Sub(5, 14), Op::Call(164, vec![2, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14]), Op::Store(vec![20, 18, 21]), Op::Call(125, vec![12, 19, 22, 17, 9, 18], 1, false), Op::AssertEq(vec![23], vec![14], None), Op::Add(4, 14), Op::Call(165, vec![10, 13, 2, 17, 24, 18], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 17, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_166() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![6], 1, false), Op::Call(246, vec![7], 1, false), Op::Sub(33, 32), Op::EqZero(34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(242, vec![8], 1, false), Op::Const(G::from_u64(3)), Op::Call(142, vec![4, 5], 1, false), Op::Add(38, 39), Op::AssertEq(vec![37], vec![40], None), Op::Call(252, vec![9], 1, false), Op::Sub(41, 32), Op::EqZero(42), Op::AssertEq(vec![43], vec![36], None), Op::Call(242, vec![10], 1, false), Op::AssertEq(vec![44], vec![36], None), Op::Store(vec![36, 36, 36])], ctrl: Ctrl::MatchContinue(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![45]) }), (G::from_u64(1), Block { ops: vec![Op::Call(133, vec![5, 45], 1, false)], ctrl: Ctrl::Yield(1, vec![46]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(133, vec![3, 46], 1, false), Op::Call(133, vec![2, 47], 1, false), Op::Call(133, vec![1, 48], 1, false), Op::Call(243, vec![0, 49], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51]), Op::Call(174, vec![50, 52], 18, false), Op::Const(G::from_u64(256)), Op::Mul(71, 54), Op::Const(G::from_u64(65536)), Op::Mul(73, 55), Op::Const(G::from_u64(16777216)), Op::Mul(75, 56), Op::Const(G::from_u64(4294967296)), Op::Mul(77, 57), Op::Const(G::from_u64(1099511627776)), Op::Mul(79, 58), Op::Const(G::from_u64(281474976710656)), Op::Mul(81, 59), Op::Const(G::from_u64(72057594037927936)), Op::Mul(83, 60), Op::Add(82, 84), Op::Add(80, 85), Op::Add(78, 86), Op::Add(76, 87), Op::Add(74, 88), Op::Add(72, 89), Op::Add(53, 90), Op::Mul(71, 62), Op::Mul(73, 63), Op::Mul(75, 64), Op::Mul(77, 65), Op::Mul(79, 66), Op::Mul(81, 67), Op::Mul(83, 68), Op::Add(97, 98), Op::Add(96, 99), Op::Add(95, 100), Op::Add(94, 101), Op::Add(93, 102), Op::Add(92, 103), Op::Add(61, 104), Op::Call(137, vec![69, 6, 7, 30], 2, false), Op::Call(131, vec![10, 52], 1, false), Op::Call(243, vec![107, 108], 1, false), Op::Call(135, vec![109, 6], 1, false), Op::Call(136, vec![110, 11, 12, 13, 14, 15, 16, 17, 18, 31], 2, false), Op::Add(32, 28), Op::Const(G::from_u64(33)), Op::U32LessThan(113, 114), Op::AssertEq(vec![115], vec![51], None), Op::Call(158, vec![111, 112, 29, 113], 1, false), Op::Call(162, vec![8, 116, 19, 20, 21, 22, 4, 5, 23, 24, 27, 28, 113], 1, false), Op::AssertEq(vec![117], vec![51], None), Op::Const(G::from_u64(0)), Op::Call(161, vec![8, 9, 118, 29], 1, false), Op::Call(157, vec![111, 112, 119, 91, 105, 1, 2, 3, 4, 5, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 113, 106, 6, 10, 32], 1, false), Op::Call(165, vec![9, 6, 120, 116, 118, 113], 1, false)], ctrl: Ctrl::Return(2, vec![121]) })) }))) }, layout: FunctionLayout { input_size: 32, selectors: 3, auxiliaries: 55, lookups: 31 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_167() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::EqZero(1), Op::Mul(2, 3)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_168() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 7, 8]), Op::Store(vec![9, 6, 10]), Op::Store(vec![9, 5, 11]), Op::Store(vec![9, 4, 12]), Op::Store(vec![9, 3, 13]), Op::Store(vec![9, 2, 14]), Op::Store(vec![9, 1, 15]), Op::Store(vec![9, 0, 16])], ctrl: Ctrl::Return(0, vec![17]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_169() -> Function { + Function { body: Block { ops: vec![Op::Call(168, vec![24, 25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Call(168, vec![16, 17, 18, 19, 20, 21, 22, 23, 33], 1, false), Op::Call(168, vec![8, 9, 10, 11, 12, 13, 14, 15, 34], 1, false), Op::Call(168, vec![0, 1, 2, 3, 4, 5, 6, 7, 35], 1, false)], ctrl: Ctrl::Return(0, vec![36]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_170() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Call(170, vec![4, 1], 1, false), Op::Call(168, vec![29, 30, 31, 32, 33, 34, 35, 36, 37], 1, false), Op::Call(168, vec![21, 22, 23, 24, 25, 26, 27, 28, 38], 1, false), Op::Call(168, vec![13, 14, 15, 16, 17, 18, 19, 20, 39], 1, false), Op::Call(168, vec![5, 6, 7, 8, 9, 10, 11, 12, 40], 1, false)], ctrl: Ctrl::Return(1, vec![41]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 41, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_171() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(171, vec![4, 1], 1, false), Op::Call(168, vec![3, 5, 5, 5, 5, 5, 5, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_172() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Const(G::from_u64(0)), Op::Store(vec![38, 38, 38, 38, 38, 38, 38, 38]), Op::Store(vec![5, 6, 7, 8, 9, 10, 5, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36]), Op::Call(75, vec![0, 37, 38, 38, 39, 40, 41], 1, false), Op::Call(74, vec![42], 32, false), Op::Call(105, vec![71, 72, 73, 74, 37], 1, false), Op::Call(105, vec![67, 68, 69, 70, 75], 1, false), Op::Call(105, vec![63, 64, 65, 66, 76], 1, false), Op::Call(105, vec![59, 60, 61, 62, 77], 1, false), Op::Call(105, vec![55, 56, 57, 58, 78], 1, false), Op::Call(105, vec![51, 52, 53, 54, 79], 1, false), Op::Call(105, vec![47, 48, 49, 50, 80], 1, false), Op::Call(105, vec![43, 44, 45, 46, 81], 1, false), Op::Call(126, vec![82, 37], 1, false), Op::Load(3, 83)], ctrl: Ctrl::Match(84, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 89)], ctrl: Ctrl::Match(90, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(93, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 95)], ctrl: Ctrl::Match(96, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 98)], ctrl: Ctrl::Match(99, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 101)], ctrl: Ctrl::Match(102, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 104)], ctrl: Ctrl::Match(105, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![85, 88, 91, 94, 97, 100, 103, 106, 82, 107]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 22)], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 6, 9, 12, 15, 18, 21, 24, 0, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 74, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_173() -> Function { + Function { body: Block { ops: vec![Op::Call(172, vec![0, 1], 10, false), Op::Const(G::from_u64(1020)), Op::Sub(9, 12), Op::Add(8, 13), Op::Add(7, 14), Op::Add(6, 15), Op::EqZero(16), Op::Add(4, 5), Op::Add(3, 18), Op::Add(2, 19), Op::EqZero(20), Op::Const(G::from_u64(1)), Op::Sub(22, 21), Op::Mul(17, 23), Op::Sub(22, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(173, vec![10, 11], 10, false)], ctrl: Ctrl::Return(1, vec![26, 27, 28, 29, 30, 31, 32, 33, 34, 35]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 27, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_174() -> Function { + Function { body: Block { ops: vec![Op::Call(173, vec![0, 1], 10, false), Op::Call(173, vec![10, 11], 10, false)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 21, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_175() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(175, vec![4, 7], 1, false), Op::Store(vec![5, 3, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_176() -> Function { + Function { body: Block { ops: vec![Op::Call(172, vec![0, 1], 10, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4), Op::U8BitDecomposition(5), Op::U8BitDecomposition(6), Op::Const(G::from_u64(1)), Op::Store(vec![45, 45, 45]), Op::Call(168, vec![37, 38, 39, 40, 41, 42, 43, 44, 46], 1, false), Op::Call(168, vec![29, 30, 31, 32, 33, 34, 35, 36, 47], 1, false), Op::Call(168, vec![21, 22, 23, 24, 25, 26, 27, 28, 48], 1, false), Op::Call(168, vec![13, 14, 15, 16, 17, 18, 19, 20, 49], 1, false), Op::Call(175, vec![50, 2], 1, false)], ctrl: Ctrl::Return(0, vec![51, 11, 12]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 49, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_177() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(168, vec![1, 2, 3, 4, 5, 6, 7, 8, 10], 1, false), Op::Call(243, vec![0, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_178() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(170, vec![1, 3], 1, false), Op::Call(243, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_179() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![1, 14, 0]), Op::Store(vec![1, 13, 15]), Op::Store(vec![1, 12, 16]), Op::Store(vec![1, 11, 17]), Op::Store(vec![1, 10, 18]), Op::Store(vec![1, 9, 19]), Op::Store(vec![1, 5, 20]), Op::Store(vec![1, 8, 21]), Op::Store(vec![1, 7, 22]), Op::Store(vec![1, 6, 23]), Op::Store(vec![1, 5, 24]), Op::Store(vec![1, 4, 25]), Op::Store(vec![1, 3, 26]), Op::Store(vec![1, 2, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 15 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_180() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(180, vec![11, 1], 1, false), Op::Call(168, vec![3, 4, 5, 6, 7, 8, 9, 10, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_181() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_182() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(4, 5), Op::Add(3, 6), Op::Mul(0, 1), Op::Mul(1, 0), Op::Add(8, 9), Op::Const(G::from_u64(1)), Op::Sub(2, 11), Op::Call(182, vec![7, 10, 12], 2, false)], ctrl: Ctrl::Return(1, vec![13, 14]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_183() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1753635133440165772))], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 1), Op::Call(183, vec![2], 1, false), Op::Mul(3, 3)], ctrl: Ctrl::Return(2, vec![4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_184() -> Function { + Function { body: Block { ops: vec![Op::Call(182, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6)], ctrl: Ctrl::Return(0, vec![7, 8]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_185() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Sub(0, 2), Op::Call(185, vec![3], 1, false), Op::Mul(1, 4)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_186() -> Function { + Function { body: Block { ops: vec![Op::Call(182, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6), Op::Call(183, vec![2], 1, false), Op::UnconstrainedGInverse(9), Op::Mul(9, 10), Op::Sub(11, 5), Op::Mul(9, 12), Op::AssertEq(vec![13], vec![6], None), Op::Mul(10, 12), Op::AssertEq(vec![14], vec![6], None), Op::Sub(0, 5), Op::Sub(1, 6), Op::Mul(15, 15), Op::Const(G::from_u64(7)), Op::Mul(16, 16), Op::Mul(18, 19), Op::Sub(17, 20), Op::UnconstrainedGInverse(21), Op::Mul(21, 22), Op::Sub(23, 5), Op::Mul(21, 24), Op::AssertEq(vec![25], vec![6], None), Op::Mul(22, 24), Op::AssertEq(vec![26], vec![6], None), Op::Mul(15, 22), Op::Sub(6, 16), Op::Mul(28, 22), Op::Mul(7, 27), Op::Mul(8, 29), Op::Mul(18, 31), Op::Add(30, 32), Op::Mul(7, 29), Op::Mul(8, 27), Op::Add(34, 35), Op::Sub(0, 10), Op::Mul(37, 37), Op::Sub(38, 20), Op::UnconstrainedGInverse(39), Op::Mul(39, 40), Op::Sub(41, 5), Op::Mul(39, 42), Op::AssertEq(vec![43], vec![6], None), Op::Mul(40, 42), Op::AssertEq(vec![44], vec![6], None), Op::Mul(37, 40), Op::Mul(28, 40), Op::Mul(7, 45), Op::Mul(8, 46), Op::Mul(18, 48), Op::Add(47, 49), Op::Mul(7, 46), Op::Mul(8, 45), Op::Add(51, 52), Op::Mul(7, 7), Op::Mul(8, 8), Op::Mul(18, 55), Op::Sub(54, 56), Op::UnconstrainedGInverse(57), Op::Mul(57, 58), Op::Sub(59, 5), Op::Mul(57, 60), Op::AssertEq(vec![61], vec![6], None), Op::Mul(58, 60), Op::AssertEq(vec![62], vec![6], None), Op::Mul(7, 58), Op::Sub(6, 8), Op::Mul(64, 58)], ctrl: Ctrl::Return(0, vec![33, 36, 50, 53, 37, 16, 63, 65]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 39, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_187() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(11, 12), Op::Add(10, 4), Op::Add(13, 5)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_188() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Mul(2, 4), Op::Const(G::from_u64(7)), Op::Mul(3, 5), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(11, 12), Op::Add(0, 10), Op::Add(1, 13)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_189() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(188, vec![2, 3, 6, 7], 2, false), Op::Call(189, vec![8], 1, false), Op::Store(vec![9, 10, 11, 12])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_190() -> Function { + Function { body: Block { ops: vec![Op::Call(248, vec![0, 1], 4, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![16, 19]) }), (G::from_u64(1), Block { ops: vec![Op::Add(16, 17), Op::Add(16, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(250, vec![4, 18], 2, false)], ctrl: Ctrl::Return(1, vec![21, 22]) }), (G::from_u64(1), Block { ops: vec![Op::Call(250, vec![5, 18], 2, false)], ctrl: Ctrl::Return(2, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(250, vec![2, 18], 2, false)], ctrl: Ctrl::Return(3, vec![21, 22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(250, vec![3, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }), (G::from_u64(4), Block { ops: vec![Op::Call(250, vec![6, 18], 2, false)], ctrl: Ctrl::Return(5, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(250, vec![7, 18], 2, false)], ctrl: Ctrl::Return(6, vec![21, 22]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(250, vec![8, 16], 2, false)], ctrl: Ctrl::Return(7, vec![19, 20]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(8, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(9, vec![11, 12]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(10, vec![13, 14]) }), (G::from_u64(6), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(190, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Add(19, 21), Op::Add(20, 22)], ctrl: Ctrl::Return(11, vec![23, 24]) }), (G::from_u64(7), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(190, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Sub(19, 21), Op::Sub(20, 22)], ctrl: Ctrl::Return(12, vec![23, 24]) }), (G::from_u64(8), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(190, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Mul(19, 21), Op::Const(G::from_u64(7)), Op::Mul(20, 22), Op::Mul(24, 25), Op::Add(23, 26), Op::Mul(19, 22), Op::Mul(20, 21), Op::Add(28, 29)], ctrl: Ctrl::Return(13, vec![27, 30]) }), (G::from_u64(9), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Const(G::from_u64(0)), Op::Sub(21, 19), Op::Sub(21, 20)], ctrl: Ctrl::Return(14, vec![22, 23]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_191() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(190, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Call(187, vec![0, 1, 2, 3, 22, 23], 2, false), Op::Call(191, vec![24, 25, 2, 3, 21, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_192() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 4), Op::Const(G::from_u64(7)), Op::Mul(1, 5), Op::Mul(9, 10), Op::Add(8, 11), Op::Mul(0, 5), Op::Mul(1, 4), Op::Add(13, 14), Op::Const(G::from_u64(0)), Op::Mul(2, 6), Op::Mul(3, 7), Op::Mul(9, 18), Op::Add(17, 19), Op::Mul(2, 7), Op::Mul(3, 6), Op::Add(21, 22), Op::Mul(9, 20), Op::Mul(16, 23), Op::Mul(9, 25), Op::Add(24, 26), Op::Mul(9, 23), Op::Mul(16, 20), Op::Add(28, 29), Op::Add(12, 27), Op::Add(15, 30), Op::Mul(0, 6), Op::Mul(1, 7), Op::Mul(9, 34), Op::Add(33, 35), Op::Mul(0, 7), Op::Mul(1, 6), Op::Add(37, 38), Op::Mul(2, 4), Op::Mul(3, 5), Op::Mul(9, 41), Op::Add(40, 42), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(44, 45), Op::Add(36, 43), Op::Add(39, 46)], ctrl: Ctrl::Return(0, vec![31, 32, 47, 48]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 17, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_193() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![22, 22, 22, 22]) }), (G::from_u64(0), Block { ops: vec![Op::Call(193, vec![21, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 4, false), Op::Call(192, vec![22, 23, 24, 25, 1, 2, 3, 4], 4, false), Op::Call(190, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Add(26, 30), Op::Add(27, 31)], ctrl: Ctrl::Return(1, vec![32, 33, 28, 29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 14, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_194() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(44, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(193, vec![46, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 4, false), Op::Add(48, 22), Op::Add(49, 23), Op::Add(50, 24), Op::Add(51, 25), Op::Call(190, vec![30, 45, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false), Op::Call(192, vec![14, 15, 16, 17, 52, 53, 54, 55], 4, false), Op::Mul(56, 10), Op::Const(G::from_u64(7)), Op::Mul(57, 11), Op::Mul(63, 64), Op::Add(62, 65), Op::Mul(56, 11), Op::Mul(57, 10), Op::Add(67, 68), Op::Add(58, 66), Op::Add(59, 69), Op::Mul(56, 12), Op::Mul(57, 13), Op::Mul(63, 73), Op::Add(72, 74), Op::Mul(56, 13), Op::Mul(57, 12), Op::Add(76, 77), Op::Add(60, 75), Op::Add(61, 78), Op::Call(192, vec![10, 11, 12, 13, 52, 53, 54, 55], 4, false), Op::Const(G::from_u64(1)), Op::Sub(85, 6), Op::Add(5, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(250, vec![35, 88], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 91), Op::Add(7, 92), Op::Call(250, vec![35, 93], 2, false), Op::Const(G::from_u64(0)), Op::Call(250, vec![36, 96], 2, false), Op::Add(97, 18), Op::Add(98, 19), Op::Call(250, vec![36, 91], 2, false), Op::Add(101, 20), Op::Add(102, 21), Op::Sub(99, 89), Op::Sub(100, 90), Op::Sub(103, 94), Op::Sub(104, 95), Op::Call(192, vec![81, 82, 83, 84, 105, 106, 107, 108], 4, false), Op::Sub(109, 70), Op::Sub(110, 71), Op::Call(187, vec![0, 1, 2, 3, 113, 114], 2, false), Op::Sub(111, 79), Op::Sub(112, 80), Op::Call(187, vec![115, 116, 2, 3, 117, 118], 2, false)], ctrl: Ctrl::Return(1, vec![119, 120]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(8, 88)], ctrl: Ctrl::Match(89, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(250, vec![35, 90], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 93), Op::Add(7, 94), Op::Call(250, vec![35, 95], 2, false), Op::Const(G::from_u64(2)), Op::Add(7, 98), Op::Add(7, 99), Op::Call(250, vec![35, 100], 2, false), Op::Const(G::from_u64(3)), Op::Add(7, 103), Op::Add(7, 104), Op::Call(250, vec![35, 105], 2, false), Op::Sub(101, 91), Op::Sub(102, 92), Op::Sub(106, 96), Op::Sub(107, 97), Op::Call(192, vec![81, 82, 83, 84, 108, 109, 110, 111], 4, false), Op::Sub(112, 70), Op::Sub(113, 71), Op::Call(187, vec![0, 1, 2, 3, 116, 117], 2, false), Op::Sub(114, 79), Op::Sub(115, 80), Op::Call(187, vec![118, 119, 2, 3, 120, 121], 2, false), Op::Add(5, 93), Op::Const(G::from_u64(0)), Op::Call(194, vec![122, 123, 2, 3, 47, 124, 6, 94, 9, 9, 93, 125, 125, 125, 125, 125, 125, 125, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(2, vec![126, 127]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 90), Op::Sub(8, 90), Op::Call(194, vec![0, 1, 2, 3, 47, 91, 6, 7, 92, 9, 81, 82, 83, 84, 70, 71, 79, 80, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(3, vec![93, 94]) }))) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 44, selectors: 4, auxiliaries: 46, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_195() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(191, vec![28, 28, 25, 26, 1, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false), Op::Sub(17, 15), Op::Sub(28, 28), Op::Mul(31, 27), Op::Const(G::from_u64(7)), Op::Mul(32, 28), Op::Mul(34, 35), Op::Add(33, 36), Op::Mul(31, 28), Op::Mul(32, 27), Op::Add(38, 39), Op::Mul(21, 37), Op::Mul(22, 40), Op::Mul(34, 42), Op::Add(41, 43), Op::Mul(21, 40), Op::Mul(22, 37), Op::Add(45, 46), Op::Sub(18, 16), Op::Mul(48, 27), Op::Add(49, 36), Op::Mul(48, 28), Op::Add(51, 39), Op::Mul(21, 50), Op::Mul(22, 52), Op::Mul(34, 54), Op::Add(53, 55), Op::Mul(21, 52), Op::Mul(22, 50), Op::Add(57, 58), Op::Load(4, 2)], ctrl: Ctrl::Match(60, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(250, vec![9, 64], 2, false), Op::Call(250, vec![8, 64], 2, false), Op::Sub(65, 67), Op::Sub(66, 68), Op::Add(69, 44), Op::Add(70, 47), Op::Call(187, vec![29, 30, 25, 26, 71, 72], 2, false), Op::Const(G::from_u64(1)), Op::Call(250, vec![9, 75], 2, false), Op::Call(250, vec![8, 75], 2, false), Op::Sub(76, 78), Op::Sub(77, 79), Op::Add(80, 56), Op::Add(81, 59), Op::Call(187, vec![73, 74, 25, 26, 82, 83], 2, false)], ctrl: Ctrl::Return(0, vec![84, 85]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(242, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::Call(194, vec![29, 30, 25, 26, 2, 64, 65, 64, 3, 3, 66, 64, 64, 64, 64, 64, 64, 64, 44, 47, 56, 59, 11, 28, 12, 28, 13, 28, 14, 28, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 28, selectors: 2, auxiliaries: 29, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_196() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![8, 7, 8, 10]), Op::Store(vec![8, 6, 8, 11]), Op::Store(vec![8, 5, 8, 12]), Op::Store(vec![8, 4, 8, 13]), Op::Store(vec![8, 3, 8, 14]), Op::Store(vec![8, 2, 8, 15]), Op::Store(vec![8, 1, 8, 16]), Op::Store(vec![8, 0, 8, 17])], ctrl: Ctrl::Return(0, vec![18]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 10, lookups: 10 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_197() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 9]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(3, 6), Op::Const(G::from_u64(7)), Op::Mul(4, 7), Op::Mul(10, 11), Op::Add(9, 12), Op::Mul(3, 7), Op::Mul(4, 6), Op::Add(14, 15), Op::Mul(3, 1), Op::Mul(4, 2), Op::Mul(10, 18), Op::Add(17, 19), Op::Mul(3, 2), Op::Mul(4, 1), Op::Add(21, 22), Op::Call(197, vec![8, 1, 2, 20, 23], 2, false), Op::Add(13, 24), Op::Add(16, 25)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_198() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(17, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Return(18, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 19, auxiliaries: 19, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_199() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(1, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![Op::Call(239, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(239, vec![4, 7], 1, false)], ctrl: Ctrl::Return(2, vec![6, 8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 4, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_200() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![31]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![2, 9], 1, false), Op::Const(G::from_u64(32)), Op::U8LessThan(31, 32), Op::Const(G::from_u64(1)), Op::AssertEq(vec![33], vec![34], None), Op::Call(198, vec![24], 1, false), Op::Call(250, vec![3, 9], 2, false), Op::Call(239, vec![4, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![38, 39], 1, false), Op::Call(239, vec![38, 34], 1, false), Op::Call(239, vec![5, 9], 1, false), Op::Call(239, vec![42, 39], 1, false), Op::Call(239, vec![42, 34], 1, false), Op::Call(250, vec![1, 9], 2, false)], ctrl: Ctrl::MatchContinue(45, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(1, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(2, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![Op::Call(239, vec![7, 46], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![47, 48], 1, false), Op::Const(G::from_u64(1)), Op::Call(239, vec![47, 50], 1, false)], ctrl: Ctrl::Yield(3, vec![49, 51]) })].into_iter().collect(), None) })].into_iter().collect(), None, 2, 3, 3, Box::new(Block { ops: vec![Op::Call(242, vec![40], 1, false), Op::Sub(49, 27), Op::EqZero(50), Op::Const(G::from_u64(1)), Op::AssertEq(vec![51], vec![52], None), Op::Call(242, vec![41], 1, false), Op::Sub(53, 27), Op::EqZero(54), Op::AssertEq(vec![55], vec![52], None), Op::Call(242, vec![43], 1, false), Op::Sub(56, 29), Op::EqZero(57), Op::AssertEq(vec![58], vec![52], None), Op::Call(242, vec![44], 1, false), Op::Sub(59, 29), Op::EqZero(60), Op::AssertEq(vec![61], vec![52], None), Op::Call(242, vec![47], 1, false), Op::Sub(62, 28), Op::EqZero(63), Op::AssertEq(vec![64], vec![52], None), Op::Call(242, vec![48], 1, false), Op::Sub(65, 28), Op::EqZero(66), Op::AssertEq(vec![67], vec![52], None), Op::Call(182, vec![18, 19, 31], 2, false), Op::Const(G::from_u64(0)), Op::Sub(68, 52), Op::Sub(69, 70), Op::Call(183, vec![31], 1, false), Op::UnconstrainedGInverse(73), Op::Mul(73, 74), Op::Sub(75, 52), Op::Mul(73, 76), Op::AssertEq(vec![77], vec![70], None), Op::Mul(74, 76), Op::AssertEq(vec![78], vec![70], None), Op::Sub(18, 52), Op::Sub(19, 70), Op::Mul(79, 79), Op::Const(G::from_u64(7)), Op::Mul(80, 80), Op::Mul(82, 83), Op::Sub(81, 84), Op::UnconstrainedGInverse(85), Op::Mul(85, 86), Op::Sub(87, 52), Op::Mul(85, 88), Op::AssertEq(vec![89], vec![70], None), Op::Mul(86, 88), Op::AssertEq(vec![90], vec![70], None), Op::Mul(79, 86), Op::Sub(70, 80), Op::Mul(92, 86), Op::Mul(71, 91), Op::Mul(72, 93), Op::Mul(82, 95), Op::Add(94, 96), Op::Mul(71, 93), Op::Mul(72, 91), Op::Add(98, 99), Op::Sub(18, 74), Op::Mul(101, 101), Op::Sub(102, 84), Op::UnconstrainedGInverse(103), Op::Mul(103, 104), Op::Sub(105, 52), Op::Mul(103, 106), Op::AssertEq(vec![107], vec![70], None), Op::Mul(104, 106), Op::AssertEq(vec![108], vec![70], None), Op::Mul(101, 104), Op::Mul(92, 104), Op::Mul(71, 109), Op::Mul(72, 110), Op::Mul(82, 112), Op::Add(111, 113), Op::Mul(71, 110), Op::Mul(72, 109), Op::Add(115, 116), Op::Mul(71, 71), Op::Mul(72, 72), Op::Mul(82, 119), Op::Sub(118, 120), Op::UnconstrainedGInverse(121), Op::Mul(121, 122), Op::Sub(123, 52), Op::Mul(121, 124), Op::AssertEq(vec![125], vec![70], None), Op::Mul(122, 124), Op::AssertEq(vec![126], vec![70], None), Op::Mul(71, 122), Op::Sub(70, 72), Op::Mul(128, 122), Op::Store(vec![52, 52, 52, 52]), Op::Store(vec![70, 37, 70, 130]), Op::Store(vec![70, 36, 70, 131]), Op::Store(vec![70, 11, 70, 132]), Op::Store(vec![70, 10, 70, 133]), Op::Store(vec![70, 15, 70, 134]), Op::Store(vec![70, 14, 70, 135]), Op::Store(vec![70, 13, 70, 136]), Op::Store(vec![70, 12, 70, 137]), Op::Call(185, vec![31], 1, false), Op::Call(183, vec![31], 1, false), Op::Mul(139, 140), Op::UnconstrainedGInverse(141), Op::Mul(141, 142), Op::Sub(143, 52), Op::Mul(141, 144), Op::AssertEq(vec![145], vec![70], None), Op::Mul(142, 144), Op::AssertEq(vec![146], vec![70], None), Op::Call(191, vec![70, 70, 16, 17, 23, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false), Op::Sub(36, 10), Op::Sub(70, 70), Op::Mul(149, 142), Op::Mul(150, 70), Op::Mul(82, 152), Op::Add(151, 153), Op::Mul(149, 70), Op::Mul(150, 142), Op::Add(155, 156), Op::Mul(114, 154), Op::Mul(117, 157), Op::Mul(82, 159), Op::Add(158, 160), Op::Mul(114, 157), Op::Mul(117, 154), Op::Add(162, 163), Op::Sub(37, 11), Op::Mul(165, 142), Op::Add(166, 153), Op::Mul(165, 70), Op::Add(168, 156), Op::Mul(114, 167), Op::Mul(117, 169), Op::Mul(82, 171), Op::Add(170, 172), Op::Mul(114, 169), Op::Mul(117, 167), Op::Add(174, 175), Op::Load(4, 25)], ctrl: Ctrl::MatchContinue(177, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(250, vec![44, 181], 2, false), Op::Call(250, vec![43, 181], 2, false), Op::Sub(182, 184), Op::Sub(183, 185), Op::Add(186, 161), Op::Add(187, 164), Op::Call(187, vec![147, 148, 16, 17, 188, 189], 2, false), Op::Const(G::from_u64(1)), Op::Call(250, vec![44, 192], 2, false), Op::Call(250, vec![43, 192], 2, false), Op::Sub(193, 195), Op::Sub(194, 196), Op::Add(197, 173), Op::Add(198, 176), Op::Call(187, vec![190, 191, 16, 17, 199, 200], 2, false)], ctrl: Ctrl::Yield(4, vec![201, 202]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(242, vec![25], 1, false), Op::Const(G::from_u64(1)), Op::Call(194, vec![147, 148, 16, 17, 25, 181, 182, 181, 26, 26, 183, 181, 181, 181, 181, 181, 181, 181, 161, 164, 173, 176, 12, 70, 13, 70, 14, 70, 15, 70, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false)], ctrl: Ctrl::Yield(5, vec![184, 185]) })].into_iter().collect(), None, 2, 12, 6, Box::new(Block { ops: vec![Op::Call(239, vec![8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![183, 184], 1, false), Op::Call(189, vec![185], 1, false), Op::Call(242, vec![186], 1, false), Op::Sub(187, 35), Op::EqZero(188), Op::Const(G::from_u64(1)), Op::AssertEq(vec![189], vec![190], None), Op::Call(182, vec![18, 19, 31], 2, false), Op::Call(197, vec![186, 191, 192, 190, 184], 2, false), Op::Mul(181, 127), Op::Const(G::from_u64(7)), Op::Mul(182, 129), Op::Mul(196, 197), Op::Add(195, 198), Op::Mul(181, 129), Op::Mul(182, 127), Op::Add(200, 201), Op::Sub(199, 193), Op::EqZero(203), Op::Sub(202, 194), Op::EqZero(205), Op::Mul(204, 206), Op::AssertEq(vec![207], vec![190], None), Op::Add(9, 190), Op::Call(200, vec![30, 1, 2, 3, 4, 5, 6, 7, 8, 208, 36, 37, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Return(6, vec![209]) })) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 20, selectors: 7, auxiliaries: 152, lookups: 50 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_201() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![13, 13]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(13, 5), Op::Const(G::from_u64(65536)), Op::Mul(15, 6), Op::Const(G::from_u64(16777216)), Op::Mul(17, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 11), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(4, 32), Op::Const(G::from_u64(0)), Op::Call(201, vec![0, 1, 12], 2, false), Op::Mul(0, 35), Op::Const(G::from_u64(7)), Op::Mul(1, 36), Op::Mul(38, 39), Op::Add(37, 40), Op::Mul(0, 36), Op::Mul(1, 35), Op::Add(42, 43), Op::Add(33, 41), Op::Add(34, 44)], ctrl: Ctrl::Return(1, vec![45, 46]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 17, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_202() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(201, vec![5, 6, 8], 2, false), Op::Add(3, 10), Op::Add(4, 11), Op::Mul(12, 12), Op::Const(G::from_u64(7)), Op::Mul(13, 13), Op::Mul(15, 16), Op::Sub(14, 17), Op::UnconstrainedGInverse(18), Op::Mul(18, 19), Op::Const(G::from_u64(1)), Op::Sub(20, 21), Op::Mul(18, 22), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None), Op::Mul(19, 22), Op::AssertEq(vec![25], vec![24], None), Op::Mul(12, 19), Op::Sub(24, 13), Op::Mul(27, 19), Op::Add(0, 26), Op::Add(1, 28), Op::Call(202, vec![29, 30, 9, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![31, 32]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_203() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 4), Op::Mul(2, 5), Op::Const(G::from_u64(0)), Op::AssertEq(vec![6], vec![7], None), Op::Call(203, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_204() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Call(204, vec![12, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(204, vec![12, 15], 1, false), Op::Store(vec![16, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17])], ctrl: Ctrl::Return(2, vec![18]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_205() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(205, vec![5, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(205, vec![5, 8], 1, false), Op::Store(vec![9, 3, 4, 10])], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_206() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(2, 3), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::Const(G::from_u64(256)), Op::Mul(10, 3), Op::Const(G::from_u64(65536)), Op::Mul(12, 4), Op::Const(G::from_u64(16777216)), Op::Mul(14, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 9), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(2, 29), Op::AssertEq(vec![30], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(9, 31), Op::Add(8, 32), Op::Add(7, 33), Op::Add(6, 34), Op::EqZero(35), Op::Add(4, 5), Op::Add(3, 37), Op::Add(2, 38), Op::EqZero(39), Op::Const(G::from_u64(1)), Op::Sub(41, 40), Op::Mul(36, 42), Op::Sub(41, 43), Op::AssertEq(vec![44], vec![41], None), Op::Call(168, vec![2, 3, 4, 5, 6, 7, 8, 9, 1], 1, false)], ctrl: Ctrl::Return(0, vec![45]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_207() -> Function { + Function { body: Block { ops: vec![Op::Call(241, vec![0], 1, false), Op::Call(208, vec![0, 1], 1, false), Op::Call(206, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_208() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(246, vec![3], 1, false), Op::Call(208, vec![4, 1], 1, false), Op::Call(180, vec![3, 6], 1, false), Op::Call(206, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_209() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![2], 1, false), Op::Call(207, vec![3, 4], 1, false), Op::Call(171, vec![2, 6], 1, false), Op::Call(206, vec![5, 7], 1, false), Op::Call(170, vec![1, 8], 1, false), Op::Call(171, vec![0, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_210() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(210, vec![7, 1], 1, false), Op::Call(209, vec![3, 4, 5, 6, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_211() -> Function { + Function { body: Block { ops: vec![Op::Call(247, vec![0], 1, false), Op::Call(212, vec![0, 1], 1, false), Op::Call(206, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_212() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(246, vec![3], 1, false), Op::Call(212, vec![12, 1], 1, false), Op::Call(168, vec![4, 5, 6, 7, 8, 9, 10, 11, 14], 1, false), Op::Call(180, vec![3, 15], 1, false), Op::Call(206, vec![13, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_213() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(211, vec![3, 5], 1, false), Op::Call(210, vec![2, 6], 1, false), Op::Call(244, vec![2], 1, false), Op::Call(206, vec![8, 7], 1, false), Op::Call(170, vec![1, 9], 1, false), Op::Call(180, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![12, 25, 11]), Op::Store(vec![12, 24, 26]), Op::Store(vec![12, 23, 27]), Op::Store(vec![12, 22, 28]), Op::Store(vec![12, 21, 29]), Op::Store(vec![12, 20, 30]), Op::Store(vec![12, 16, 31]), Op::Store(vec![12, 19, 32]), Op::Store(vec![12, 18, 33]), Op::Store(vec![12, 17, 34]), Op::Store(vec![12, 16, 35]), Op::Store(vec![12, 15, 36]), Op::Store(vec![12, 14, 37]), Op::Store(vec![12, 13, 38]), Op::Call(174, vec![39, 5], 18, false), Op::Call(168, vec![48, 49, 50, 51, 52, 53, 54, 55, 5], 1, false), Op::Call(168, vec![40, 41, 42, 43, 44, 45, 46, 47, 58], 1, false), Op::Call(243, vec![56, 59], 1, false), Op::Call(174, vec![60, 5], 18, false), Op::Call(168, vec![69, 70, 71, 72, 73, 74, 75, 76, 5], 1, false), Op::Call(168, vec![61, 62, 63, 64, 65, 66, 67, 68, 79], 1, false), Op::Call(243, vec![77, 80], 1, false), Op::Const(G::from_u64(256)), Op::Mul(82, 41), Op::Const(G::from_u64(65536)), Op::Mul(84, 42), Op::Const(G::from_u64(16777216)), Op::Mul(86, 43), Op::Const(G::from_u64(4294967296)), Op::Mul(88, 44), Op::Const(G::from_u64(1099511627776)), Op::Mul(90, 45), Op::Const(G::from_u64(281474976710656)), Op::Mul(92, 46), Op::Const(G::from_u64(72057594037927936)), Op::Mul(94, 47), Op::Add(93, 95), Op::Add(91, 96), Op::Add(89, 97), Op::Add(87, 98), Op::Add(85, 99), Op::Add(83, 100), Op::Add(40, 101), Op::Mul(82, 49), Op::Mul(84, 50), Op::Mul(86, 51), Op::Mul(88, 52), Op::Mul(90, 53), Op::Mul(92, 54), Op::Mul(94, 55), Op::Add(108, 109), Op::Add(107, 110), Op::Add(106, 111), Op::Add(105, 112), Op::Add(104, 113), Op::Add(103, 114), Op::Add(48, 115), Op::Mul(82, 62), Op::Mul(84, 63), Op::Mul(86, 64), Op::Mul(88, 65), Op::Mul(90, 66), Op::Mul(92, 67), Op::Mul(94, 68), Op::Add(122, 123), Op::Add(121, 124), Op::Add(120, 125), Op::Add(119, 126), Op::Add(118, 127), Op::Add(117, 128), Op::Add(61, 129), Op::Mul(82, 70), Op::Mul(84, 71), Op::Mul(86, 72), Op::Mul(88, 73), Op::Mul(90, 74), Op::Mul(92, 75), Op::Mul(94, 76), Op::Add(136, 137), Op::Add(135, 138), Op::Add(134, 139), Op::Add(133, 140), Op::Add(132, 141), Op::Add(131, 142), Op::Add(69, 143)], ctrl: Ctrl::Return(0, vec![102, 116, 130, 144, 81]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_214() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::U8RangeCheck(11, 12), Op::Const(G::from_u64(256)), Op::Mul(13, 6), Op::Const(G::from_u64(65536)), Op::Mul(15, 7), Op::Const(G::from_u64(16777216)), Op::Mul(17, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 12), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(5, 32), Op::AssertEq(vec![33], vec![1], None), Op::Const(G::from_u64(1020)), Op::Sub(12, 34), Op::Add(11, 35), Op::Add(10, 36), Op::Add(9, 37), Op::EqZero(38), Op::Add(7, 8), Op::Add(6, 40), Op::Add(5, 41), Op::EqZero(42), Op::Const(G::from_u64(1)), Op::Sub(44, 43), Op::Mul(39, 45), Op::Sub(44, 46), Op::AssertEq(vec![47], vec![44], None), Op::Call(177, vec![0, 5, 6, 7, 8, 9, 10, 11, 12], 1, false), Op::Call(178, vec![48, 2], 1, false), Op::Store(vec![44, 44, 44]), Op::Call(131, vec![4, 50], 1, false), Op::Call(243, vec![49, 51], 1, false), Op::Call(174, vec![52, 50], 18, false), Op::Call(178, vec![69, 3], 1, false), Op::Call(174, vec![71, 50], 18, false), Op::Mul(13, 54), Op::Mul(15, 55), Op::Mul(17, 56), Op::Mul(19, 57), Op::Mul(21, 58), Op::Mul(23, 59), Op::Mul(25, 60), Op::Add(95, 96), Op::Add(94, 97), Op::Add(93, 98), Op::Add(92, 99), Op::Add(91, 100), Op::Add(90, 101), Op::Add(53, 102), Op::Mul(13, 62), Op::Mul(15, 63), Op::Mul(17, 64), Op::Mul(19, 65), Op::Mul(21, 66), Op::Mul(23, 67), Op::Mul(25, 68), Op::Add(109, 110), Op::Add(108, 111), Op::Add(107, 112), Op::Add(106, 113), Op::Add(105, 114), Op::Add(104, 115), Op::Add(61, 116), Op::Mul(13, 73), Op::Mul(15, 74), Op::Mul(17, 75), Op::Mul(19, 76), Op::Mul(21, 77), Op::Mul(23, 78), Op::Mul(25, 79), Op::Add(123, 124), Op::Add(122, 125), Op::Add(121, 126), Op::Add(120, 127), Op::Add(119, 128), Op::Add(118, 129), Op::Add(72, 130), Op::Mul(13, 81), Op::Mul(15, 82), Op::Mul(17, 83), Op::Mul(19, 84), Op::Mul(21, 85), Op::Mul(23, 86), Op::Mul(25, 87), Op::Add(137, 138), Op::Add(136, 139), Op::Add(135, 140), Op::Add(134, 141), Op::Add(133, 142), Op::Add(132, 143), Op::Add(80, 144)], ctrl: Ctrl::Return(0, vec![103, 117, 131, 145, 88]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_215() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![3], vec![6], None), Op::Call(215, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_216() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21], vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22], None)], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(10, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![22], vec![23], None), Op::Call(216, vec![11, 21], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_217() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(216, vec![3, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], None), Op::Call(217, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_218() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Load(32, 6), Op::Call(10, vec![8, 9, 10, 11, 12, 13, 14, 15, 40, 41, 42, 43, 44, 45, 46, 47], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![72], vec![73], None), Op::Call(10, vec![16, 17, 18, 19, 20, 21, 22, 23, 48, 49, 50, 51, 52, 53, 54, 55], 1, false), Op::AssertEq(vec![74], vec![73], None), Op::Call(10, vec![24, 25, 26, 27, 28, 29, 30, 31, 56, 57, 58, 59, 60, 61, 62, 63], 1, false), Op::AssertEq(vec![75], vec![73], None), Op::Call(10, vec![32, 33, 34, 35, 36, 37, 38, 39, 64, 65, 66, 67, 68, 69, 70, 71], 1, false), Op::AssertEq(vec![76], vec![73], None), Op::Call(218, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![77]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_219() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(219, vec![4], 2, false)], ctrl: Ctrl::Return(1, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_220() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![5, 6, 8], 2, false), Op::Add(3, 18), Op::Add(4, 19), Op::Mul(20, 20), Op::Const(G::from_u64(7)), Op::Mul(21, 21), Op::Mul(23, 24), Op::Sub(22, 25), Op::UnconstrainedGInverse(26), Op::Mul(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Mul(26, 30), Op::Const(G::from_u64(0)), Op::AssertEq(vec![31], vec![32], None), Op::Mul(27, 30), Op::AssertEq(vec![33], vec![32], None), Op::Mul(20, 27), Op::Sub(32, 21), Op::Mul(35, 27), Op::Const(G::from_u64(256)), Op::Mul(37, 10), Op::Const(G::from_u64(65536)), Op::Mul(39, 11), Op::Const(G::from_u64(16777216)), Op::Mul(41, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(43, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(45, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(47, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(49, 16), Op::Add(48, 50), Op::Add(46, 51), Op::Add(44, 52), Op::Add(42, 53), Op::Add(40, 54), Op::Add(38, 55), Op::Add(9, 56), Op::Mul(34, 57), Op::Mul(36, 32), Op::Mul(23, 59), Op::Add(58, 60), Op::Mul(34, 32), Op::Mul(36, 57), Op::Add(62, 63), Op::Add(0, 61), Op::Add(1, 64), Op::Call(220, vec![65, 66, 17, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_221() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(26, vec![1]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(27, vec![1]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(28, vec![1]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(29, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(30, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(31, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(32, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(33, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_222() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(221, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], None), Op::Call(222, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_223() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(223, vec![3], 1, false), Op::Add(2, 4)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_224() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![2], None), Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::Const(G::from_u64(256)), Op::Mul(11, 4), Op::Const(G::from_u64(65536)), Op::Mul(13, 5), Op::Const(G::from_u64(16777216)), Op::Mul(15, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(17, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(19, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(21, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(23, 10), Op::Add(22, 24), Op::Add(20, 25), Op::Add(18, 26), Op::Add(16, 27), Op::Add(14, 28), Op::Add(12, 29), Op::Add(3, 30), Op::AssertEq(vec![31], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(10, 32), Op::Add(9, 33), Op::Add(8, 34), Op::Add(7, 35), Op::EqZero(36), Op::Add(5, 6), Op::Add(4, 38), Op::Add(3, 39), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::Sub(42, 41), Op::Mul(37, 43), Op::Sub(42, 44), Op::AssertEq(vec![45], vec![42], None), Op::Add(9, 10), Op::Add(8, 46), Op::Add(7, 47), Op::Add(6, 48), Op::AssertEq(vec![49], vec![2], None), Op::Sub(5, 42), Op::Mul(5, 50), Op::AssertEq(vec![51], vec![2], None), Op::Add(3, 4), Op::Mul(5, 52), Op::AssertEq(vec![53], vec![2], None)], ctrl: Ctrl::Return(0, vec![42]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_225() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 20)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 30), Op::Const(G::from_u64(1)), Op::AssertEq(vec![31, 32, 33, 34, 35, 36, 37, 38, 39, 40], vec![41, 41, 41, 41, 41, 41, 41, 41, 41, 41], None)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 27, 28, 29]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_226() -> Function { + Function { body: Block { ops: vec![Op::U8LessThan(0, 1), Op::Sub(0, 1), Op::EqZero(4), Op::Mul(5, 2), Op::Add(3, 6)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_227() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(226, vec![0, 8, 16], 1, false), Op::Call(226, vec![1, 9, 17], 1, false), Op::Call(226, vec![2, 10, 18], 1, false), Op::Call(226, vec![3, 11, 19], 1, false), Op::Call(226, vec![4, 12, 20], 1, false), Op::Call(226, vec![5, 13, 21], 1, false), Op::Call(226, vec![6, 14, 22], 1, false), Op::Call(226, vec![7, 15, 23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_228() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(11, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(25, 6), Op::Const(G::from_u64(65536)), Op::Mul(27, 7), Op::Const(G::from_u64(16777216)), Op::Mul(29, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(31, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(33, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(35, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(37, 12), Op::Add(36, 38), Op::Add(34, 39), Op::Add(32, 40), Op::Add(30, 41), Op::Add(28, 42), Op::Add(26, 43), Op::Add(5, 44), Op::Const(G::from_u64(1)), Op::Add(45, 46), Op::Const(G::from_u64(0)), Op::AssertEq(vec![47], vec![48], None), Op::Mul(25, 17), Op::Mul(27, 18), Op::Mul(29, 19), Op::Mul(31, 20), Op::Mul(33, 21), Op::Mul(35, 22), Op::Mul(37, 23), Op::Add(54, 55), Op::Add(53, 56), Op::Add(52, 57), Op::Add(51, 58), Op::Add(50, 59), Op::Add(49, 60), Op::Add(16, 61), Op::AssertEq(vec![62], vec![46], None), Op::Call(225, vec![4], 24, false), Op::Call(225, vec![15], 24, false), Op::Mul(25, 64), Op::Mul(27, 65), Op::Mul(29, 66), Op::Mul(31, 67), Op::Mul(33, 68), Op::Mul(35, 69), Op::Mul(37, 70), Op::Add(116, 117), Op::Add(115, 118), Op::Add(114, 119), Op::Add(113, 120), Op::Add(112, 121), Op::Add(111, 122), Op::Add(63, 123), Op::Const(G::from_u64(16)), Op::AssertEq(vec![124], vec![125], None), Op::Mul(25, 88), Op::Mul(27, 89), Op::Mul(29, 90), Op::Mul(31, 91), Op::Mul(33, 92), Op::Mul(35, 93), Op::Mul(37, 94), Op::Add(131, 132), Op::Add(130, 133), Op::Add(129, 134), Op::Add(128, 135), Op::Add(127, 136), Op::Add(126, 137), Op::Add(87, 138), Op::AssertEq(vec![139], vec![125], None), Op::Mul(25, 72), Op::Mul(27, 73), Op::Mul(29, 74), Op::Mul(31, 75), Op::Mul(33, 76), Op::Mul(35, 77), Op::Mul(37, 78), Op::Add(145, 146), Op::Add(144, 147), Op::Add(143, 148), Op::Add(142, 149), Op::Add(141, 150), Op::Add(140, 151), Op::Add(71, 152), Op::Mul(25, 96), Op::Mul(27, 97), Op::Mul(29, 98), Op::Mul(31, 99), Op::Mul(33, 100), Op::Mul(35, 101), Op::Mul(37, 102), Op::Add(159, 160), Op::Add(158, 161), Op::Add(157, 162), Op::Add(156, 163), Op::Add(155, 164), Op::Add(154, 165), Op::Add(95, 166), Op::AssertEq(vec![167], vec![153], None), Op::Mul(25, 80), Op::Mul(27, 81), Op::Mul(29, 82), Op::Mul(31, 83), Op::Mul(33, 84), Op::Mul(35, 85), Op::Mul(37, 86), Op::Add(173, 174), Op::Add(172, 175), Op::Add(171, 176), Op::Add(170, 177), Op::Add(169, 178), Op::Add(168, 179), Op::Add(79, 180), Op::Mul(25, 104), Op::Mul(27, 105), Op::Mul(29, 106), Op::Mul(31, 107), Op::Mul(33, 108), Op::Mul(35, 109), Op::Mul(37, 110), Op::Add(187, 188), Op::Add(186, 189), Op::Add(185, 190), Op::Add(184, 191), Op::Add(183, 192), Op::Add(182, 193), Op::Add(103, 194), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(196, 197), Op::U8RangeCheck(198, 199), Op::U8RangeCheck(200, 201), Op::U8RangeCheck(202, 203), Op::Mul(25, 197), Op::Mul(27, 198), Op::Mul(29, 199), Op::Mul(31, 200), Op::Mul(33, 201), Op::Mul(35, 202), Op::Mul(37, 203), Op::Add(209, 210), Op::Add(208, 211), Op::Add(207, 212), Op::Add(206, 213), Op::Add(205, 214), Op::Add(204, 215), Op::Add(196, 216), Op::AssertEq(vec![217], vec![181], None), Op::Const(G::from_u64(1020)), Op::Sub(203, 218), Op::Add(202, 219), Op::Add(201, 220), Op::Add(200, 221), Op::EqZero(222), Op::Add(198, 199), Op::Add(197, 224), Op::Add(196, 225), Op::EqZero(226), Op::Sub(46, 227), Op::Mul(223, 228), Op::Sub(46, 229), Op::AssertEq(vec![230], vec![46], None), Op::UnconstrainedGToBytes(195), Op::U8RangeCheck(231, 232), Op::U8RangeCheck(233, 234), Op::U8RangeCheck(235, 236), Op::U8RangeCheck(237, 238), Op::Mul(25, 232), Op::Mul(27, 233), Op::Mul(29, 234), Op::Mul(31, 235), Op::Mul(33, 236), Op::Mul(35, 237), Op::Mul(37, 238), Op::Add(244, 245), Op::Add(243, 246), Op::Add(242, 247), Op::Add(241, 248), Op::Add(240, 249), Op::Add(239, 250), Op::Add(231, 251), Op::AssertEq(vec![252], vec![195], None), Op::Sub(238, 218), Op::Add(237, 253), Op::Add(236, 254), Op::Add(235, 255), Op::EqZero(256), Op::Add(233, 234), Op::Add(232, 258), Op::Add(231, 259), Op::EqZero(260), Op::Sub(46, 261), Op::Mul(257, 262), Op::Sub(46, 263), Op::AssertEq(vec![264], vec![46], None), Op::Call(227, vec![196, 197, 198, 199, 200, 201, 202, 203, 231, 232, 233, 234, 235, 236, 237, 238], 1, false), Op::AssertEq(vec![265], vec![46], None), Op::Sub(153, 1), Op::EqZero(266), Op::UnconstrainedGToBytes(153), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::U8RangeCheck(272, 273), Op::U8RangeCheck(274, 275), Op::Mul(25, 269), Op::Mul(27, 270), Op::Mul(29, 271), Op::Mul(31, 272), Op::Mul(33, 273), Op::Mul(35, 274), Op::Mul(37, 275), Op::Add(281, 282), Op::Add(280, 283), Op::Add(279, 284), Op::Add(278, 285), Op::Add(277, 286), Op::Add(276, 287), Op::Add(268, 288), Op::AssertEq(vec![289], vec![153], None), Op::Sub(275, 218), Op::Add(274, 290), Op::Add(273, 291), Op::Add(272, 292), Op::EqZero(293), Op::Add(270, 271), Op::Add(269, 295), Op::Add(268, 296), Op::EqZero(297), Op::Sub(46, 298), Op::Mul(294, 299), Op::Sub(46, 300), Op::AssertEq(vec![301], vec![46], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(302, 303), Op::U8RangeCheck(304, 305), Op::U8RangeCheck(306, 307), Op::U8RangeCheck(308, 309), Op::Mul(25, 303), Op::Mul(27, 304), Op::Mul(29, 305), Op::Mul(31, 306), Op::Mul(33, 307), Op::Mul(35, 308), Op::Mul(37, 309), Op::Add(315, 316), Op::Add(314, 317), Op::Add(313, 318), Op::Add(312, 319), Op::Add(311, 320), Op::Add(310, 321), Op::Add(302, 322), Op::AssertEq(vec![323], vec![1], None), Op::Sub(309, 218), Op::Add(308, 324), Op::Add(307, 325), Op::Add(306, 326), Op::EqZero(327), Op::Add(304, 305), Op::Add(303, 329), Op::Add(302, 330), Op::EqZero(331), Op::Sub(46, 332), Op::Mul(328, 333), Op::Sub(46, 334), Op::AssertEq(vec![335], vec![46], None), Op::Call(227, vec![268, 269, 270, 271, 272, 273, 274, 275, 302, 303, 304, 305, 306, 307, 308, 309], 1, false), Op::Sub(46, 336), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(338, 339), Op::U8RangeCheck(340, 341), Op::U8RangeCheck(342, 343), Op::U8RangeCheck(344, 345), Op::Mul(25, 339), Op::Mul(27, 340), Op::Mul(29, 341), Op::Mul(31, 342), Op::Mul(33, 343), Op::Mul(35, 344), Op::Mul(37, 345), Op::Add(351, 352), Op::Add(350, 353), Op::Add(349, 354), Op::Add(348, 355), Op::Add(347, 356), Op::Add(346, 357), Op::Add(338, 358), Op::AssertEq(vec![359], vec![2], None), Op::Sub(345, 218), Op::Add(344, 360), Op::Add(343, 361), Op::Add(342, 362), Op::EqZero(363), Op::Add(340, 341), Op::Add(339, 365), Op::Add(338, 366), Op::EqZero(367), Op::Sub(46, 368), Op::Mul(364, 369), Op::Sub(46, 370), Op::AssertEq(vec![371], vec![46], None), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(372, 373), Op::U8RangeCheck(374, 375), Op::U8RangeCheck(376, 377), Op::U8RangeCheck(378, 379), Op::Mul(25, 373), Op::Mul(27, 374), Op::Mul(29, 375), Op::Mul(31, 376), Op::Mul(33, 377), Op::Mul(35, 378), Op::Mul(37, 379), Op::Add(385, 386), Op::Add(384, 387), Op::Add(383, 388), Op::Add(382, 389), Op::Add(381, 390), Op::Add(380, 391), Op::Add(372, 392), Op::AssertEq(vec![393], vec![181], None), Op::Sub(379, 218), Op::Add(378, 394), Op::Add(377, 395), Op::Add(376, 396), Op::EqZero(397), Op::Add(374, 375), Op::Add(373, 399), Op::Add(372, 400), Op::EqZero(401), Op::Sub(46, 402), Op::Mul(398, 403), Op::Sub(46, 404), Op::AssertEq(vec![405], vec![46], None), Op::Call(227, vec![338, 339, 340, 341, 342, 343, 344, 345, 372, 373, 374, 375, 376, 377, 378, 379], 1, false), Op::Mul(267, 406), Op::Add(337, 407), Op::AssertEq(vec![408], vec![46], None), Op::Call(228, vec![24, 153, 195], 1, false)], ctrl: Ctrl::Return(1, vec![409]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_229() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![46], None), Op::AssertEq(vec![2], vec![46], None), Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![47], None)], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(17, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(242, vec![21], 1, false), Op::EqZero(48), Op::Const(G::from_u64(0)), Op::AssertEq(vec![49], vec![50], None), Op::Call(241, vec![39], 1, false), Op::AssertEq(vec![51], vec![48], None), Op::Call(241, vec![40], 1, false), Op::AssertEq(vec![52], vec![48], None), Op::Call(241, vec![36], 1, false), Op::AssertEq(vec![53], vec![48], None), Op::Call(203, vec![17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![54], vec![55], None), Op::Call(241, vec![17], 1, false), Op::Call(247, vec![8], 1, false), Op::Sub(56, 57), Op::EqZero(58), Op::AssertEq(vec![59], vec![55], None), Op::Call(204, vec![8, 17], 1, false), Op::Call(205, vec![11, 17], 1, false), Op::Call(247, vec![60], 1, false), Op::Call(242, vec![21], 1, false), Op::Sub(62, 63), Op::EqZero(64), Op::AssertEq(vec![65], vec![55], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(215, vec![12, 17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![66], vec![67], None), Op::Call(218, vec![13, 18], 1, false), Op::AssertEq(vec![68], vec![67], None), Op::Call(215, vec![14, 22], 1, false), Op::AssertEq(vec![69], vec![67], None), Op::Call(222, vec![22], 1, false), Op::AssertEq(vec![70], vec![67], None), Op::Call(223, vec![17], 1, false), Op::Call(241, vec![22], 1, false), Op::AssertEq(vec![71], vec![72], None)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![73, 73, 73])], ctrl: Ctrl::Yield(0, vec![74]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(214, vec![41, 16, 19, 20, 21], 5, false), Op::Const(G::from_u64(0)), Op::Call(202, vec![79, 79, 15, 42, 43, 44, 45], 2, false), Op::Call(200, vec![60, 61, 22, 21, 39, 40, 37, 38, 36, 79, 80, 81, 42, 43, 44, 45, 74, 75, 76, 77], 1, false), Op::Call(247, vec![60], 1, false)], ctrl: Ctrl::Match(23, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![23], 1, false), Op::Call(246, vec![24], 1, false), Op::Sub(85, 84), Op::EqZero(86), Op::Const(G::from_u64(1)), Op::AssertEq(vec![87], vec![88], None), Op::Call(242, vec![25], 1, false), Op::Const(G::from_u64(3)), Op::Call(142, vec![37, 38], 1, false), Op::Add(90, 91), Op::AssertEq(vec![89], vec![92], None), Op::Call(252, vec![26], 1, false), Op::Sub(93, 84), Op::EqZero(94), Op::AssertEq(vec![95], vec![88], None), Op::Call(242, vec![27], 1, false), Op::AssertEq(vec![96], vec![88], None), Op::Store(vec![88, 88, 88])], ctrl: Ctrl::MatchContinue(37, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![97]) }), (G::from_u64(1), Block { ops: vec![Op::Call(133, vec![38, 97], 1, false)], ctrl: Ctrl::Yield(3, vec![98]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(133, vec![36, 98], 1, false), Op::Call(133, vec![40, 99], 1, false), Op::Call(133, vec![39, 100], 1, false), Op::Call(243, vec![78, 101], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![103, 103, 103]), Op::Call(174, vec![102, 104], 18, false), Op::Const(G::from_u64(256)), Op::Mul(123, 106), Op::Const(G::from_u64(65536)), Op::Mul(125, 107), Op::Const(G::from_u64(16777216)), Op::Mul(127, 108), Op::Const(G::from_u64(4294967296)), Op::Mul(129, 109), Op::Const(G::from_u64(1099511627776)), Op::Mul(131, 110), Op::Const(G::from_u64(281474976710656)), Op::Mul(133, 111), Op::Const(G::from_u64(72057594037927936)), Op::Mul(135, 112), Op::Add(134, 136), Op::Add(132, 137), Op::Add(130, 138), Op::Add(128, 139), Op::Add(126, 140), Op::Add(124, 141), Op::Add(105, 142), Op::Mul(123, 114), Op::Mul(125, 115), Op::Mul(127, 116), Op::Mul(129, 117), Op::Mul(131, 118), Op::Mul(133, 119), Op::Mul(135, 120), Op::Add(149, 150), Op::Add(148, 151), Op::Add(147, 152), Op::Add(146, 153), Op::Add(145, 154), Op::Add(144, 155), Op::Add(113, 156), Op::Call(137, vec![121, 23, 24, 5], 2, false), Op::Call(131, vec![27, 104], 1, false), Op::Call(243, vec![159, 160], 1, false), Op::Call(135, vec![161, 23], 1, false), Op::Call(136, vec![162, 28, 29, 30, 31, 32, 33, 34, 35, 6], 2, false), Op::Add(84, 0), Op::Const(G::from_u64(33)), Op::U32LessThan(165, 166), Op::AssertEq(vec![167], vec![103], None), Op::Call(158, vec![163, 164, 4, 165], 1, false), Op::Call(162, vec![25, 168, 18, 19, 20, 73, 37, 38, 61, 22, 83, 0, 165], 1, false), Op::AssertEq(vec![169], vec![103], None), Op::Const(G::from_u64(0)), Op::Call(161, vec![25, 26, 170, 4], 1, false), Op::Call(157, vec![163, 164, 171, 143, 157, 39, 40, 36, 37, 38, 18, 19, 20, 73, 61, 22, 76, 77, 83, 0, 165, 158, 23, 27, 84], 1, false), Op::Call(165, vec![26, 23, 172, 168, 170, 165], 1, false), Op::AssertEq(vec![173], vec![103], None), Op::Call(219, vec![21], 2, false)], ctrl: Ctrl::Return(4, vec![174, 175]) })) }))) })) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_230() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Load(26, 13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53], vec![54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54], None)], ctrl: Ctrl::Return(0, vec![20, 21]) }), (G::from_u64(0), Block { ops: vec![Op::Load(26, 13)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Call(229, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 23, 24, 25, 26, 14, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(1)), Op::Add(14, 56), Op::Add(20, 54), Op::Add(21, 55), Op::Call(230, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 27, 53, 57, 15, 16, 17, 18, 19, 58, 59], 2, false)], ctrl: Ctrl::Return(1, vec![60, 61]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_231() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(231, vec![6], 1, false), Op::Call(243, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_232() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, vec![12], 1, false), Op::Call(224, vec![15], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None), Op::Call(240, vec![14], 1, false), Op::Call(244, vec![12], 1, false), Op::AssertEq(vec![18], vec![19], None), Op::Const(G::from_u64(0)), Op::Call(228, vec![13, 20, 20], 1, false), Op::AssertEq(vec![21], vec![17], None)], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22])], ctrl: Ctrl::Yield(0, vec![23]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(213, vec![7, 22, 12, 13], 5, false), Op::Const(G::from_u64(0)), Op::Call(220, vec![28, 28, 13, 23, 24, 25, 26], 2, false), Op::Call(230, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 28, 27, 23, 24, 25, 26, 29, 30], 2, false), Op::EqZero(31), Op::EqZero(32), Op::Mul(33, 34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(231, vec![12], 1, false)], ctrl: Ctrl::Return(2, vec![37]) })) }))) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_233() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![12], 2, false), Op::Call(63, vec![16, 15], 2, false), Op::Call(29, vec![18], 2, false), Op::Call(66, vec![20, 19], 2, false), Op::Call(29, vec![22], 2, false), Op::Call(68, vec![24, 23], 2, false), Op::Add(12, 13), Op::AssertEq(vec![26], vec![27], None), Op::Call(232, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 21, 25], 1, false), Op::Call(217, vec![28, 14], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![29], vec![30], None)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 15, selectors: 1, auxiliaries: 15, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_234() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(235, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_235() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(237, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(235, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_236() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(237, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_237() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(25, vec![0], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(237, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_238() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(16, vec![16]), Op::Const(G::from_u64(1)), Op::IOGetInfo(19, vec![16]), Op::Call(1, vec![19, 20, 21], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![19, 19, 19]), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16]), Op::Store(vec![23, 24, 25, 26, 27, 28, 23, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53]), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19]), Op::Call(75, vec![22, 54, 16, 16, 55, 56, 57], 1, false), Op::Call(74, vec![58], 32, false), Op::Const(G::from_u64(256)), Op::Mul(91, 60), Op::Const(G::from_u64(65536)), Op::Mul(93, 61), Op::Const(G::from_u64(16777216)), Op::Mul(95, 62), Op::Add(94, 96), Op::Add(92, 97), Op::Add(59, 98), Op::Mul(91, 64), Op::Mul(93, 65), Op::Mul(95, 66), Op::Add(101, 102), Op::Add(100, 103), Op::Add(63, 104), Op::Mul(91, 68), Op::Mul(93, 69), Op::Mul(95, 70), Op::Add(107, 108), Op::Add(106, 109), Op::Add(67, 110), Op::Mul(91, 72), Op::Mul(93, 73), Op::Mul(95, 74), Op::Add(113, 114), Op::Add(112, 115), Op::Add(71, 116), Op::Mul(91, 76), Op::Mul(93, 77), Op::Mul(95, 78), Op::Add(119, 120), Op::Add(118, 121), Op::Add(75, 122), Op::Mul(91, 80), Op::Mul(93, 81), Op::Mul(95, 82), Op::Add(125, 126), Op::Add(124, 127), Op::Add(79, 128), Op::Mul(91, 84), Op::Mul(93, 85), Op::Mul(95, 86), Op::Add(131, 132), Op::Add(130, 133), Op::Add(83, 134), Op::Mul(91, 88), Op::Mul(93, 89), Op::Mul(95, 90), Op::Add(137, 138), Op::Add(136, 139), Op::Add(87, 140), Op::AssertEq(vec![99, 105, 111, 117, 123, 129, 135, 141], vec![0, 1, 2, 3, 4, 5, 6, 7], None), Op::Call(87, vec![22], 10, false), Op::Call(87, vec![151], 10, false), Op::Call(87, vec![161], 10, false), Op::Call(87, vec![171], 10, false), Op::Call(87, vec![181], 10, false), Op::Call(87, vec![191], 10, false), Op::Call(87, vec![201], 10, false), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19]), Op::Store(vec![16, 203, 204, 205, 206, 207, 208, 209, 210, 212]), Op::Store(vec![16, 193, 194, 195, 196, 197, 198, 199, 200, 213]), Op::Store(vec![16, 183, 184, 185, 186, 187, 188, 189, 190, 214]), Op::Store(vec![16, 173, 174, 175, 176, 177, 178, 179, 180, 215]), Op::Store(vec![16, 163, 164, 165, 166, 167, 168, 169, 170, 216]), Op::Store(vec![16, 153, 154, 155, 156, 157, 158, 159, 160, 217]), Op::Store(vec![16, 143, 144, 145, 146, 147, 148, 149, 150, 218]), Op::Call(87, vec![211], 10, false), Op::Call(100, vec![229, 220], 3, false), Op::Call(101, vec![232], 3, false), Op::Call(102, vec![235, 220], 2, false), Op::Store(vec![16, 221, 222, 223, 224, 225, 226, 227, 228, 231]), Op::Call(251, vec![219, 238], 1, false), Op::Load(3, 237), Op::AssertEq(vec![240, 241, 242], vec![19, 19, 19], None), Op::Const(G::from_u64(2)), Op::IOGetInfo(243, vec![16]), Op::Call(1, vec![243, 244, 245], 1, true), Op::Call(75, vec![246, 54, 16, 16, 55, 56, 57], 1, false), Op::Call(74, vec![247], 32, false), Op::Mul(91, 249), Op::Mul(93, 250), Op::Mul(95, 251), Op::Add(281, 282), Op::Add(280, 283), Op::Add(248, 284), Op::Mul(91, 253), Op::Mul(93, 254), Op::Mul(95, 255), Op::Add(287, 288), Op::Add(286, 289), Op::Add(252, 290), Op::Mul(91, 257), Op::Mul(93, 258), Op::Mul(95, 259), Op::Add(293, 294), Op::Add(292, 295), Op::Add(256, 296), Op::Mul(91, 261), Op::Mul(93, 262), Op::Mul(95, 263), Op::Add(299, 300), Op::Add(298, 301), Op::Add(260, 302), Op::Mul(91, 265), Op::Mul(93, 266), Op::Mul(95, 267), Op::Add(305, 306), Op::Add(304, 307), Op::Add(264, 308), Op::Mul(91, 269), Op::Mul(93, 270), Op::Mul(95, 271), Op::Add(311, 312), Op::Add(310, 313), Op::Add(268, 314), Op::Mul(91, 273), Op::Mul(93, 274), Op::Mul(95, 275), Op::Add(317, 318), Op::Add(316, 319), Op::Add(272, 320), Op::Mul(91, 277), Op::Mul(93, 278), Op::Mul(95, 279), Op::Add(323, 324), Op::Add(322, 325), Op::Add(276, 326), Op::AssertEq(vec![285, 291, 297, 303, 309, 315, 321, 327], vec![8, 9, 10, 11, 12, 13, 14, 15], None), Op::Call(26, vec![246], 2, false), Op::Call(235, vec![329, 328], 2, false), Op::Load(3, 331), Op::AssertEq(vec![332, 333, 334], vec![19, 19, 19], None), Op::Call(29, vec![17], 2, false), Op::Call(63, vec![336, 335], 2, false), Op::Call(29, vec![338], 2, false), Op::Call(66, vec![340, 339], 2, false), Op::Call(29, vec![342], 2, false), Op::Call(68, vec![344, 343], 2, false), Op::Add(17, 18), Op::AssertEq(vec![346], vec![347], None), Op::Call(232, vec![142, 152, 162, 172, 182, 192, 202, 239, 230, 233, 234, 236, 337, 341, 345], 1, false), Op::Call(217, vec![348, 330], 1, false), Op::AssertEq(vec![349], vec![19], None), Op::AssertEq(vec![19], vec![19], None)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 201, lookups: 42 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_239() -> Function { + Function { body: Block { ops: vec![Op::Call(253, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_240() -> Function { + Function { body: Block { ops: vec![Op::Load(26, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(0), Block { ops: vec![Op::Call(240, vec![26], 1, false), Op::Const(G::from_u64(1)), Op::Add(27, 28)], ctrl: Ctrl::Return(1, vec![29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_241() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(241, vec![3], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 5)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_242() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(242, vec![4], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_243() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(243, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_244() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(244, vec![6], 1, false), Op::Const(G::from_u64(1)), Op::Add(7, 8)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_245() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(245, vec![7], 1, false), Op::Const(G::from_u64(1)), Op::Add(8, 9)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_246() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(246, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Add(11, 12)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_247() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::Add(12, 13)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_248() -> Function { + Function { body: Block { ops: vec![Op::Call(255, vec![0, 1], 1, false), Op::Load(6, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_249() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_250() -> Function { + Function { body: Block { ops: vec![Op::Call(254, vec![0, 1], 1, false), Op::Load(4, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_251() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(251, vec![11, 1], 1, false), Op::Store(vec![12, 3, 4, 5, 6, 7, 8, 9, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_252() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(252, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_253() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(253, vec![0, 3], 1, false), Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_254() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(254, vec![0, 3], 1, false), Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_255() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(255, vec![0, 3], 1, false), Op::Load(6, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21(), expected_function_22(), expected_function_23(), expected_function_24(), expected_function_25(), expected_function_26(), expected_function_27(), expected_function_28(), expected_function_29(), expected_function_30(), expected_function_31(), expected_function_32(), expected_function_33(), expected_function_34(), expected_function_35(), expected_function_36(), expected_function_37(), expected_function_38(), expected_function_39(), expected_function_40(), expected_function_41(), expected_function_42(), expected_function_43(), expected_function_44(), expected_function_45(), expected_function_46(), expected_function_47(), expected_function_48(), expected_function_49(), expected_function_50(), expected_function_51(), expected_function_52(), expected_function_53(), expected_function_54(), expected_function_55(), expected_function_56(), expected_function_57(), expected_function_58(), expected_function_59(), expected_function_60(), expected_function_61(), expected_function_62(), expected_function_63(), expected_function_64(), expected_function_65(), expected_function_66(), expected_function_67(), expected_function_68(), expected_function_69(), expected_function_70(), expected_function_71(), expected_function_72(), expected_function_73(), expected_function_74(), expected_function_75(), expected_function_76(), expected_function_77(), expected_function_78(), expected_function_79(), expected_function_80(), expected_function_81(), expected_function_82(), expected_function_83(), expected_function_84(), expected_function_85(), expected_function_86(), expected_function_87(), expected_function_88(), expected_function_89(), expected_function_90(), expected_function_91(), expected_function_92(), expected_function_93(), expected_function_94(), expected_function_95(), expected_function_96(), expected_function_97(), expected_function_98(), expected_function_99(), expected_function_100(), expected_function_101(), expected_function_102(), expected_function_103(), expected_function_104(), expected_function_105(), expected_function_106(), expected_function_107(), expected_function_108(), expected_function_109(), expected_function_110(), expected_function_111(), expected_function_112(), expected_function_113(), expected_function_114(), expected_function_115(), expected_function_116(), expected_function_117(), expected_function_118(), expected_function_119(), expected_function_120(), expected_function_121(), expected_function_122(), expected_function_123(), expected_function_124(), expected_function_125(), expected_function_126(), expected_function_127(), expected_function_128(), expected_function_129(), expected_function_130(), expected_function_131(), expected_function_132(), expected_function_133(), expected_function_134(), expected_function_135(), expected_function_136(), expected_function_137(), expected_function_138(), expected_function_139(), expected_function_140(), expected_function_141(), expected_function_142(), expected_function_143(), expected_function_144(), expected_function_145(), expected_function_146(), expected_function_147(), expected_function_148(), expected_function_149(), expected_function_150(), expected_function_151(), expected_function_152(), expected_function_153(), expected_function_154(), expected_function_155(), expected_function_156(), expected_function_157(), expected_function_158(), expected_function_159(), expected_function_160(), expected_function_161(), expected_function_162(), expected_function_163(), expected_function_164(), expected_function_165(), expected_function_166(), expected_function_167(), expected_function_168(), expected_function_169(), expected_function_170(), expected_function_171(), expected_function_172(), expected_function_173(), expected_function_174(), expected_function_175(), expected_function_176(), expected_function_177(), expected_function_178(), expected_function_179(), expected_function_180(), expected_function_181(), expected_function_182(), expected_function_183(), expected_function_184(), expected_function_185(), expected_function_186(), expected_function_187(), expected_function_188(), expected_function_189(), expected_function_190(), expected_function_191(), expected_function_192(), expected_function_193(), expected_function_194(), expected_function_195(), expected_function_196(), expected_function_197(), expected_function_198(), expected_function_199(), expected_function_200(), expected_function_201(), expected_function_202(), expected_function_203(), expected_function_204(), expected_function_205(), expected_function_206(), expected_function_207(), expected_function_208(), expected_function_209(), expected_function_210(), expected_function_211(), expected_function_212(), expected_function_213(), expected_function_214(), expected_function_215(), expected_function_216(), expected_function_217(), expected_function_218(), expected_function_219(), expected_function_220(), expected_function_221(), expected_function_222(), expected_function_223(), expected_function_224(), expected_function_225(), expected_function_226(), expected_function_227(), expected_function_228(), expected_function_229(), expected_function_230(), expected_function_231(), expected_function_232(), expected_function_233(), expected_function_234(), expected_function_235(), expected_function_236(), expected_function_237(), expected_function_238(), expected_function_239(), expected_function_240(), expected_function_241(), expected_function_242(), expected_function_243(), expected_function_244(), expected_function_245(), expected_function_246(), expected_function_247(), expected_function_248(), expected_function_249(), expected_function_250(), expected_function_251(), expected_function_252(), expected_function_253(), expected_function_254(), expected_function_255()], memory_sizes: vec![3, 4, 5, 6, 7, 8, 10, 11, 26, 32, 34], circuits: vec![Circuit { members: vec![0, 2, 11, 12, 96, 119, 120, 121, 122, 164, 180, 188], layout: FunctionLayout { input_size: 8, selectors: 40, auxiliaries: 20, lookups: 7 } }, Circuit { members: vec![10], layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![24, 38, 88, 90, 97, 141, 182, 189, 203, 204, 205, 247], layout: FunctionLayout { input_size: 3, selectors: 25, auxiliaries: 18, lookups: 6 } }, Circuit { members: vec![25, 73, 74, 89, 125, 136, 148, 157, 165, 173, 174, 177, 194], layout: FunctionLayout { input_size: 44, selectors: 26, auxiliaries: 137, lookups: 14 } }, Circuit { members: vec![26, 46, 54, 57, 59, 108, 137, 155, 170, 176, 201, 237, 245, 251], layout: FunctionLayout { input_size: 9, selectors: 26, auxiliaries: 98, lookups: 32 } }, Circuit { members: vec![29, 255], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 3 } }, Circuit { members: vec![33, 43, 47, 105, 124, 138, 149, 151, 159, 160, 163, 175], layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![34, 241], layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![35], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 } }, Circuit { members: vec![36, 44, 45, 77, 87, 110, 118, 127, 132, 133, 171], layout: FunctionLayout { input_size: 2, selectors: 21, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![37, 192], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 23, lookups: 3 } }, Circuit { members: vec![39, 50, 102, 116, 128, 135, 139, 154, 158, 161, 178, 183, 185, 197, 252], layout: FunctionLayout { input_size: 8, selectors: 31, auxiliaries: 42, lookups: 9 } }, Circuit { members: vec![41, 94], layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![60], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 } }, Circuit { members: vec![63], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 } }, Circuit { members: vec![66], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 } }, Circuit { members: vec![68], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 } }, Circuit { members: vec![75], layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![76, 78, 79, 100, 172, 200], layout: FunctionLayout { input_size: 20, selectors: 25, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![83], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![84], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![85], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![86], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![92, 101, 142, 150, 156, 162, 198, 202, 235, 244], layout: FunctionLayout { input_size: 25, selectors: 37, auxiliaries: 46, lookups: 20 } }, Circuit { members: vec![93], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 } }, Circuit { members: vec![109, 187], layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![111], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 } }, Circuit { members: vec![112, 123, 131], layout: FunctionLayout { input_size: 4, selectors: 10, auxiliaries: 34, lookups: 13 } }, Circuit { members: vec![113], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 } }, Circuit { members: vec![114], layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 } }, Circuit { members: vec![117, 126, 250, 254], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![130], layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 } }, Circuit { members: vec![140], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 } }, Circuit { members: vec![143], layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 } }, Circuit { members: vec![144, 145, 146, 147, 191, 193], layout: FunctionLayout { input_size: 19, selectors: 12, auxiliaries: 14, lookups: 7 } }, Circuit { members: vec![168], layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![190], layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 } }, Circuit { members: vec![206], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![207], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![208], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![209], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 } }, Circuit { members: vec![210], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![211], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![212], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 } }, Circuit { members: vec![213], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 } }, Circuit { members: vec![214], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 } }, Circuit { members: vec![215], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![216], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 } }, Circuit { members: vec![217], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![218], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 } }, Circuit { members: vec![219], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 } }, Circuit { members: vec![220], layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 } }, Circuit { members: vec![221], layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 } }, Circuit { members: vec![222], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![223], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![224], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 } }, Circuit { members: vec![225], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 } }, Circuit { members: vec![226], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![227], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![228], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 } }, Circuit { members: vec![229], layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 } }, Circuit { members: vec![230], layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 } }, Circuit { members: vec![231], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![232], layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 } }, Circuit { members: vec![238], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 201, lookups: 42 } }, Circuit { members: vec![239, 242, 253], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![240], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 } }, Circuit { members: vec![243], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![246], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![248], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 } }, Circuit { members: vec![249], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [190, 78, 33, 75, 247, 82, 112, 163, 173, 204, 83, 141, 6, 196, 161, 203, 161, 99, 163, 87, 1, 40, 26, 136, 174, 21, 15, 159, 197, 168, 147, 208], complete: false, expected: expected_program, functions: &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, output_size: 64, seed_words: 194, schema: &SCHEMA_76, pack: pack_76, pack_typed: pack_76_typed, pack_checked: pack_76_checked, write: write_76 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, output_size: 1, seed_words: 146, schema: &SCHEMA_78, pack: pack_78, pack_typed: pack_78_typed, pack_checked: pack_78_checked, write: |seed, offsets, row| { write_78(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, output_size: 1, seed_words: 158, schema: &SCHEMA_79, pack: pack_79, pack_typed: pack_79_typed, pack_checked: pack_79_checked, write: |seed, offsets, row| { write_79(seed, offsets, row); Ok(()) } }), +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_83, pack: pack_83, pack_typed: pack_83_typed, pack_checked: pack_83_checked, write: |seed, offsets, row| { write_83(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 109, lookups: 34 }, output_size: 3, seed_words: 69, schema: &SCHEMA_100, pack: pack_100, pack_typed: pack_100_typed, pack_checked: pack_100_checked, write: |seed, offsets, row| { write_100(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, output_size: 1, seed_words: 201, schema: &SCHEMA_114, pack: pack_114, pack_typed: pack_114_typed, pack_checked: pack_114_checked, write: |seed, offsets, row| { write_114(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 74, lookups: 25 }, output_size: 10, seed_words: 76, schema: &SCHEMA_172, pack: pack_172, pack_typed: pack_172_typed, pack_checked: pack_172_checked, write: write_172 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 20, selectors: 7, auxiliaries: 152, lookups: 50 }, output_size: 1, seed_words: 94, schema: &SCHEMA_200, pack: pack_200, pack_typed: pack_200_typed, pack_checked: pack_200_checked, write: write_200 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_217, pack: pack_217, pack_typed: pack_217_typed, pack_checked: pack_217_checked, write: write_217 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 1, seed_words: 25, schema: &SCHEMA_227, pack: pack_227, pack_typed: pack_227_typed, pack_checked: pack_227_checked, write: |seed, offsets, row| { write_227(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +] }; diff --git a/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs b/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs new file mode 100644 index 000000000..074271e6f --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs @@ -0,0 +1,274 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_multi_stark_contract() -> *const u8; + fn aiur_trace_multi_stark_schema() -> *const u8; + pub(super) fn aiur_trace_multi_stark_76(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_78(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_79(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_83(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_100(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_114(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_172(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_200(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_217(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_227(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([190, 78, 33, 75, 247, 82, 112, 163, 173, 204, 83, 141, 6, 196, 161, 203, 161, 99, 163, 87, 1, 40, 26, 136, 174, 21, 15, 159, 197, 168, 147, 208], aiur_trace_multi_stark_contract, aiur_trace_multi_stark_schema, &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_76), +None, +Some(aiur_trace_multi_stark_78), +Some(aiur_trace_multi_stark_79), +None, +None, +None, +Some(aiur_trace_multi_stark_83), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_100), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_114), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_172), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_200), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_217), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_227), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +], &[3, 0, 9, 0, 0, 0, 0, 0, 0, 0, 17, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 18, 12, 0, 0, 12, 0, 0, 0, 8, 6, 15, 6, 24, 6, 43, 0, 8, 0, 10, 6, 8, 6, 8, 0, 0, 8, 0, 0, 0, 12, 0, 0, 14, 0, 6, 52, 0, 0, 20, 0, 0, 17, 0, 31, 0, 0, 0, 0, 170, 137, 13, 194, 5, 146, 158, 0, 0, 0, 162, 5, 4, 6, 6, 10, 18, 11, 0, 43, 15, 8, 0, 12, 5, 0, 0, 69, 8, 8, 0, 0, 10, 0, 0, 100, 5, 7, 22, 22, 27, 201, 0, 43, 8, 6, 18, 18, 19, 15, 33, 9, 22, 8, 7, 13, 0, 27, 10, 8, 8, 0, 8, 17, 42, 8, 8, 21, 11, 3, 19, 17, 19, 20, 23, 22, 8, 6, 11, 0, 0, 16, 41, 54, 36, 10, 10, 11, 9, 30, 9, 11, 23, 0, 0, 18, 0, 43, 8, 76, 23, 23, 8, 20, 13, 6, 0, 15, 0, 6, 3, 0, 3, 0, 7, 5, 14, 24, 29, 9, 33, 81, 0, 0, 12, 2, 0, 94, 16, 15, 6, 19, 12, 4, 6, 10, 12, 11, 6, 19, 68, 48, 10, 25, 11, 78, 12, 23, 2, 7, 6, 2, 42, 4, 25, 78, 119, 59, 10, 32, 0, 0, 10, 0, 15, 217, 7, 29, 6, 7, 8, 9, 10, 13, 14, 10, 5, 8, 15, 8, 7, 8, 10], &[16, 0, 72, 0, 0, 0, 0, 0, 0, 0, 136, 72, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 112, 88, 0, 0, 96, 0, 0, 0, 56, 48, 112, 48, 184, 48, 336, 0, 56, 0, 72, 48, 56, 48, 56, 0, 0, 56, 0, 0, 0, 80, 0, 0, 96, 0, 48, 352, 0, 0, 136, 0, 0, 128, 0, 176, 0, 0, 0, 0, 432, 840, 80, 848, 40, 416, 272, 0, 0, 0, 176, 32, 32, 40, 40, 64, 112, 88, 0, 312, 96, 48, 0, 72, 40, 0, 0, 304, 48, 48, 0, 0, 64, 0, 0, 120, 32, 40, 136, 128, 128, 544, 0, 312, 40, 40, 96, 112, 120, 72, 176, 56, 120, 48, 48, 96, 0, 192, 64, 48, 48, 0, 48, 120, 280, 64, 56, 144, 72, 24, 128, 112, 144, 144, 168, 160, 56, 32, 80, 0, 0, 120, 224, 336, 216, 56, 64, 64, 48, 160, 56, 64, 112, 0, 0, 112, 0, 312, 48, 464, 168, 168, 48, 104, 96, 40, 0, 104, 0, 48, 24, 0, 24, 0, 56, 40, 88, 192, 224, 72, 256, 632, 0, 0, 88, 16, 0, 616, 120, 104, 32, 120, 64, 32, 40, 64, 72, 64, 40, 128, 432, 344, 48, 160, 40, 552, 72, 168, 16, 32, 40, 16, 232, 24, 88, 576, 688, 320, 64, 184, 0, 0, 56, 0, 104, 1144, 48, 152, 40, 48, 48, 64, 72, 96, 96, 72, 32, 56, 104, 48, 48, 56, 72]) }; diff --git a/crates/aiur/src/trace_codegen/tests.rs b/crates/aiur/src/trace_codegen/tests.rs new file mode 100644 index 000000000..d7044f076 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests.rs @@ -0,0 +1,550 @@ +use super::*; +use crate::execute::IOKeyInfo; + +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod generated; + +#[cfg(feature = "cuda-trace-codegen")] +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod generated_cuda; + +#[cfg(feature = "cuda-trace-codegen")] +mod cuda; +#[cfg(feature = "cuda-trace-codegen")] +#[allow(unreachable_pub)] +#[rustfmt::skip] +pub(crate) mod blake3; +#[cfg(feature = "cuda-trace-codegen")] +#[allow(unreachable_pub)] +#[rustfmt::skip] +pub(crate) mod blake3_cuda; + +fn io() -> IOBuffer { + IOBuffer { data: Default::default(), map: Default::default() } +} + +fn circuit_of(program: &Toplevel, function: usize) -> usize { + program.circuits.iter().position(|c| c.members.contains(&function)).unwrap() +} + +fn snapshot(record: &QueryRecord) -> Vec { + let mut words = vec![]; + for table in + record.function_queries.iter().chain(record.memory_queries.values()) + { + words.push(u64::try_from(table.len()).unwrap()); + for (key, result) in table.iter() { + words + .extend(key.iter().chain(result.output).map(|x| x.as_canonical_u64())); + words.push(result.multiplicity.as_canonical_u64()); + } + } + words +} + +fn parity(program: &Toplevel, record: &QueryRecord, io: &IOBuffer) -> usize { + let bound = generated::PROGRAM.bind(program).unwrap(); + let before = snapshot(record); + let mut checked = 0; + for (index, queries) in record.function_queries.iter().enumerate() { + let Some(writer) = bound.function(index) else { + continue; + }; + let circuit = circuit_of(program, index); + for query in 0..queries.len() { + if queries.get_index(query).unwrap().1.multiplicity == G::ZERO { + continue; + } + let mut seed = vec![u64::MAX; writer.seed_words()]; + writer.pack_row(record, io, query, false, &mut seed).unwrap(); + let mut strict = vec![u64::MAX; writer.seed_words()]; + writer.pack_row(record, io, query, true, &mut strict).unwrap(); + assert_eq!( + seed, strict, + "function {index}, query {query}: strict seed differs" + ); + let schema = writer.schema(); + assert!(schema.is_consistent()); + let mut direct = vec![0xff; schema.bytes]; + let fits = writer.pack_typed_row(record, io, query, &mut direct).unwrap(); + assert_eq!( + fits, + seed.iter().zip(schema.widths).all(|(&word, width)| width.fits(word)), + "function {index}, query {query}: typed guard" + ); + let encoding = + if fits { SeedEncoding::Typed } else { SeedEncoding::Canonical }; + let mut packed = vec![0xff; encoding.stride(schema)]; + encoding.encode(schema, &seed, &mut packed).unwrap(); + if fits { + assert_eq!(direct, packed, "direct typed seed differs"); + } else { + assert!( + SeedEncoding::Typed.encode(schema, &seed, &mut direct).is_err() + ); + } + let mut decoded = vec![0; seed.len()]; + encoding.decode(schema, &packed, &mut decoded).unwrap(); + assert_eq!(seed, decoded); + let expected = + program.main_row_for_test(circuit, index, query, record, io); + let mut actual = vec![u64::MAX; expected.len()]; + writer.write_row(&decoded, circuit, &mut actual).unwrap(); + for (column, (actual, expected)) in + actual.iter().zip(&expected).enumerate() + { + assert_eq!( + *actual, + expected.as_canonical_u64(), + "function {index}, query {query}, column {column}" + ); + assert!(*actual < G::ORDER_U64); + } + checked += 1; + } + } + #[cfg(feature = "cuda-trace-codegen")] + cuda::parity(program, record, io); + assert_eq!(before, snapshot(record), "packing changed the finalized record"); + checked +} + +fn run(function: usize, args: &[u64]) -> usize { + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let (record, _) = program + .execute(function, args.iter().copied().map(G::from_u64).collect(), &mut io) + .unwrap(); + parity(&program, &record, &io) +} + +#[test] +fn canonical_fields_zero_inverses_and_constant_degree() { + let boundary = [0, 1, 2, 255, 256, (1 << 32) - 1, 1 << 32, G::ORDER_U64 - 1]; + for a in boundary { + for b in boundary { + assert_eq!(run(0, &[a, b]), 1); + } + } + assert_eq!(run(12, &[]), 1); +} + +#[test] +fn byte_operations_and_virtual_carries() { + let boundary = [0, 1, 15, 16, 127, 128, 254, 255]; + for a in boundary { + for b in boundary { + assert_eq!(run(1, &[a, b]), 1); + } + } +} + +#[test] +fn u32_boundaries_and_virtual_values() { + let boundary = [0_u32, 1, 255, 256, 1 << 31, u32::MAX]; + for a in boundary { + for b in boundary { + let args: Vec<_> = [a, b, u32::MAX] + .iter() + .flat_map(|word| word.to_le_bytes().map(u64::from)) + .collect(); + assert_eq!(run(2, &args), 1); + } + } +} + +#[test] +fn branch_columns_and_grouped_member_offsets() { + for tag in [0, 1, 2, G::ORDER_U64 - 1] { + for value in [0, 1, 127, 255] { + assert_eq!(run(3, &[tag, value]), 1); + } + } + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for (function, args) in [ + (0, vec![G::ZERO, -G::ONE]), + (3, vec![G::ONE, G::from_u8(255)]), + (12, vec![]), + ] { + program.execute_in(function, args, &mut io, &mut record).unwrap(); + } + assert_eq!(parity(&program, &record, &io), 3); +} + +#[test] +fn call_load_dependencies_and_nonzero_pointer_namespace() { + let program = (generated::PROGRAM.expected)(); + for base in [0, 1024, 1 << 30] { + let mut io = io(); + let (record, _) = program + .execute_with_pointer_base(4, vec![G::from_u8(7)], &mut io, base) + .unwrap(); + assert_eq!(parity(&program, &record, &io), 2); + } +} + +#[test] +fn strict_alias_verification_and_unconstrained_calls() { + for value in [0, 7, G::ORDER_U64 - 1] { + assert_eq!(run(6, &[value]), 2); + assert!(run(14, &[value]) >= 1); + } + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + record.function_queries[6].insert(&[G::ZERO], &[G::ONE], G::ONE).unwrap(); + record.function_queries[5].insert(&[G::ZERO], &[G::ZERO], G::ONE).unwrap(); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(6).unwrap(); + let mut seed = vec![0; writer.seed_words()]; + writer.pack_row(&record, &io(), 0, false, &mut seed).unwrap(); + let error = writer.pack_row(&record, &io(), 0, true, &mut seed).unwrap_err(); + assert_eq!(error.function, 6); + assert_eq!(error.operation, Some(1)); + assert_eq!(error.query, Some(0)); + assert!(error.detail.contains("alias disagrees")); +} + +#[test] +fn early_returns_do_not_resolve_unexecuted_reads() { + for function in [8, 9] { + assert_eq!(run(function, &[0]), 1); + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::with_pointer_base(&program, 7); + record + .memory_queries + .get_mut(&1) + .unwrap() + .insert(&[G::from_u8(42)], &[G::from_u8(7)], G::ZERO) + .unwrap(); + let mut io = io(); + program + .execute_in(function, vec![G::from_u8(7)], &mut io, &mut record) + .unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + record.memory_queries.clear(); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(function).unwrap(); + let mut seed = vec![0; writer.seed_words()]; + let error = writer.pack_row(&record, &io, 0, false, &mut seed).unwrap_err(); + assert!(error.detail.contains("missing loaded values")); + } +} + +#[test] +fn io_reads_and_shared_branch_seed_slots() { + let program = (generated::PROGRAM.expected)(); + let channel = G::from_u8(3); + let mut io = io(); + io.data.insert(channel, vec![G::ONE, G::TWO, G::from_u8(77)]); + io.map.insert((channel, vec![G::from_u8(12)]), IOKeyInfo { idx: 0, len: 2 }); + let (record, _) = + program.execute(7, vec![channel, G::from_u8(12)], &mut io).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + for tag in [0, 1] { + let (record, _) = + program.execute(10, vec![G::from_u64(tag), channel], &mut io).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + } +} + +fn store_list(record: &mut QueryRecord, limbs: &[u64]) -> G { + let table = record.memory_queries.get_mut(&10).unwrap(); + let mut nil = [G::ZERO; 10]; + nil[0] = G::ONE; + if table.is_empty() { + table.insert(&nil, &[G::from_usize(record.pointer_base)], G::ZERO).unwrap(); + } + let mut pointer = G::from_usize(record.pointer_base); + for limb in limbs.iter().rev() { + let mut node = [G::ZERO; 10]; + node[1..9].copy_from_slice(&limb.to_le_bytes().map(G::from_u8)); + node[9] = pointer; + pointer = if let Some(query) = table.get(&node) { + query.output[0] + } else { + let pointer = G::from_usize(record.pointer_base + table.len()); + table.insert(&node, &[pointer], G::ZERO).unwrap(); + pointer + }; + } + pointer +} + +#[test] +fn big_uint_results_resolve_existing_list_nodes() { + let program = (generated::PROGRAM.expected)(); + for base in [0, 4096] { + for divisor in [vec![], vec![7], vec![3, 2]] { + let mut record = QueryRecord::with_pointer_base(&program, base); + let a = store_list(&mut record, &[u64::MAX, 9]); + let b = store_list(&mut record, &divisor); + let mut io = io(); + program.execute_in(11, vec![a, b], &mut io, &mut record).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + } + } +} + +#[test] +fn zero_output_reads_do_not_need_seeds() { + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + record + .memory_queries + .get_mut(&0) + .unwrap() + .insert(&[], &[G::ZERO], G::ZERO) + .unwrap(); + let mut io = io(); + program.execute_in(15, vec![G::ZERO], &mut io, &mut record).unwrap(); + assert_eq!(parity(&program, &record, &io), 2); +} + +#[test] +fn current_blake3_bytecode_all_stages_and_negative_multiplicities() { + let program = (generated::PROGRAM.expected)(); + assert_eq!(program.functions[17].layout.width(), 533); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(17).unwrap(); + assert_eq!(writer.seed_words(), 162); + // Multiplicity and the stage word stay full width; the 128 message bytes + // and 32 aliased output bytes narrow, so the typed seed matches the + // handwritten provider's 176 bytes without a function-name special case. + assert_eq!(writer.schema().bytes, 176); + assert_eq!(writer.schema().widths[1], SeedWidth::Full); + assert!(writer.schema().widths[2..].iter().all(|&w| w == SeedWidth::U8)); + for sample in 0..4 { + let mut state = 0x12345678_u64 + sample; + let mut args = vec![G::ZERO]; + for _ in 0..128 { + state = state.wrapping_mul(6364136223846793005).wrapping_add(1); + args.push(G::from_u8((state >> 56) as u8)); + } + let mut io = io(); + let (mut record, _) = program.execute(17, args, &mut io).unwrap(); + assert_eq!(record.function_queries[17].len(), 8); + for i in 0..8 { + *record.function_queries[17].get_index_mut(i).unwrap().1 = + if i % 2 == 0 { -G::ONE } else { G::from_u64(1 << 40) }; + } + assert_eq!(parity(&program, &record, &io), 8); + let mut seed = vec![0; writer.seed_words()]; + writer.pack_row(&record, &io, 7, true, &mut seed).unwrap(); + drop(record); + let mut row = vec![0; 533]; + writer.write_row(&seed, circuit_of(&program, 17), &mut row).unwrap(); + } +} + +#[test] +fn partial_coverage_keeps_library_and_descriptor_checks() { + let program = (generated::PROGRAM.expected)(); + let mut functions = generated::PROGRAM.functions.to_vec(); + functions[0] = None; + let mut partial = GeneratedProgram { + fingerprint: generated::PROGRAM.fingerprint, + complete: true, + expected: generated::PROGRAM.expected, + functions: Box::leak(functions.into_boxed_slice()), + }; + assert!(partial.bind(&program).is_err()); + partial.complete = false; + let bound = partial.bind(&program).unwrap(); + assert!(bound.function(0).is_none()); + assert!(bound.function(1).is_some()); + let mut changed = (generated::PROGRAM.expected)(); + changed.functions[0].body.ops.push(crate::bytecode::Op::Const(G::ONE)); + assert!(partial.bind(&changed).is_err()); + let mut functions = partial.functions.to_vec(); + functions[13] = functions[1]; + partial.functions = Box::leak(functions.into_boxed_slice()); + assert!(partial.bind(&program).is_err()); +} + +#[test] +fn library_binding_rejects_changed_callees_and_grouping() { + let mut program = (generated::PROGRAM.expected)(); + program.functions[13].body.ops.push(crate::bytecode::Op::Const(G::ONE)); + assert!(generated::PROGRAM.bind(&program).is_err()); + let mut program = (generated::PROGRAM.expected)(); + program.circuits[0].members.swap(0, 1); + assert!(generated::PROGRAM.bind(&program).is_ok()); + program.circuits[0].members.push(0); + assert!(generated::PROGRAM.bind(&program).is_err()); + let mut program = (generated::PROGRAM.expected)(); + let Ctrl::MatchContinue(_, arms, ..) = &mut program.functions[3].body.ctrl + else { + unreachable!() + }; + arms.swap_indices(0, 1); + assert!(generated::PROGRAM.bind(&program).is_err()); +} + +#[test] +fn seed_codec_guards_and_wide_fallback() { + use SeedWidth::*; + // Wider words first, in index order, so every word is naturally aligned. + static MIXED: SeedSchema = SeedSchema { + widths: &[Full, U8, U32, U16, Full, U8], + offsets: &[0, 22, 16, 20, 8, 23], + bytes: 24, + }; + assert!(MIXED.is_consistent()); + assert!(!MIXED.is_canonical()); + static SKEWED: SeedSchema = + SeedSchema { widths: &[Full, U8], offsets: &[0, 9], bytes: 16 }; + assert!(!SKEWED.is_consistent()); + static PAYLOAD_FIRST: SeedSchema = + SeedSchema { widths: &[U8, Full], offsets: &[0, 8], bytes: 16 }; + assert!(!PAYLOAD_FIRST.is_consistent()); + + let words = [G::ORDER_U64 - 1, 255, u64::from(u32::MAX), 65535, 1 << 40, 0]; + for encoding in [SeedEncoding::Typed, SeedEncoding::Canonical] { + let mut bytes = vec![0xff; encoding.stride(&MIXED)]; + encoding.encode(&MIXED, &words, &mut bytes).unwrap(); + let mut decoded = vec![0; words.len()]; + encoding.decode(&MIXED, &bytes, &mut decoded).unwrap(); + assert_eq!(words, decoded[..]); + } + let mut typed = vec![0; 24]; + SeedEncoding::Typed.encode(&MIXED, &words, &mut typed).unwrap(); + assert_eq!(&typed[..8], &(G::ORDER_U64 - 1).to_le_bytes()); + assert_eq!(&typed[8..16], &(1u64 << 40).to_le_bytes()); + assert_eq!(&typed[16..20], &u32::MAX.to_le_bytes()); + assert_eq!(&typed[20..22], &u16::MAX.to_le_bytes()); + assert_eq!(&typed[22..], &[255, 0]); + + // Each narrowed word guards its own bound; the wide fallback takes anything. + for (index, wide) in [(1, 256), (2, 1 << 32), (3, 65536), (5, 1)] { + let mut words = words; + words[index] = wide; + assert_eq!( + SeedEncoding::Typed.encode(&MIXED, &words, &mut typed).is_err(), + index != 5 + ); + let mut canonical = vec![0; 48]; + SeedEncoding::Canonical.encode(&MIXED, &words, &mut canonical).unwrap(); + } + assert!( + SeedEncoding::Typed + .encode(&MIXED, &[G::ORDER_U64, 0, 0, 0, 0, 0], &mut typed) + .is_err() + ); + assert!(SeedEncoding::Typed.encode(&MIXED, &words[..5], &mut typed).is_err()); + assert!( + SeedEncoding::Canonical.decode(&MIXED, &[0; 48], &mut [0; 5]).is_err() + ); + let mut noncanonical = [0; 48]; + noncanonical[..8].copy_from_slice(&G::ORDER_U64.to_le_bytes()); + assert!( + SeedEncoding::Canonical.decode(&MIXED, &noncanonical, &mut [0; 6]).is_err() + ); + static PADDED: SeedSchema = + SeedSchema { widths: &[Full, U8], offsets: &[0, 8], bytes: 16 }; + let mut padded = [0; 16]; + padded[15] = 1; + assert!(SeedEncoding::Typed.decode(&PADDED, &padded, &mut [0; 2]).is_err()); + padded[15] = 0; + padded[8] = 9; + let mut decoded = [0; 2]; + SeedEncoding::Typed.decode(&PADDED, &padded, &mut decoded).unwrap(); + assert_eq!(decoded, [0, 9]); +} + +#[test] +fn typed_guard_failure_leaves_the_span_full_width() { + // Function 3 narrows its value input to a byte because one arm adds it as + // a byte, but the multiply arm accepts any field element. Rows taking that + // arm with a wide value must fail the guard and pack full width. + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let (record, _) = + program.execute(3, vec![G::ZERO, G::from_u64(1 << 32)], &mut io).unwrap(); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(3).unwrap(); + assert_eq!(writer.schema().widths[2], SeedWidth::U8); + let mut typed = vec![0; writer.schema().bytes]; + assert!(!writer.pack_typed_row(&record, &io, 0, &mut typed).unwrap()); + let mut seed = vec![0; writer.seed_words()]; + writer.pack_row(&record, &io, 0, false, &mut seed).unwrap(); + assert_eq!(seed[2], 1 << 32); + assert_eq!(parity(&program, &record, &io), 1); +} + +#[test] +fn scalar_rejects_noncanonical_seed_words() { + let program = (generated::PROGRAM.expected)(); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(0).unwrap(); + let mut seed = vec![0; writer.seed_words()]; + seed[0] = G::ORDER_U64; + let mut row = vec![0; program.circuits[0].layout.width()]; + assert!(writer.write_row(&seed, 0, &mut row).is_err()); +} + +#[test] +fn nested_yields_compute_host_read_keys() { + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let channel = G::from_u8(3); + io.data.insert(channel, vec![G::ZERO, G::ONE, G::TWO, G::from_u8(3)]); + for outer in [0, 1] { + for inner in [0, 1, 2] { + let (record, _) = program + .execute( + 18, + vec![G::from_u8(outer), channel, G::from_u8(inner)], + &mut io, + ) + .unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + } + } +} + +#[test] +fn missing_match_and_inactive_queries_are_rejected() { + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let (mut record, _) = program.execute(19, vec![G::ZERO], &mut io).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(19).unwrap(); + let mut seed = vec![0; writer.seed_words()]; + writer.pack_row(&record, &io, 0, false, &mut seed).unwrap(); + seed[1] = 7; + let circuit = circuit_of(&program, 19); + let mut row = vec![0; program.circuits[circuit].layout.width()]; + let error = writer.write_row(&seed, circuit, &mut row).unwrap_err(); + assert!(error.detail.contains("no match")); + *record.function_queries[19].get_index_mut(0).unwrap().1 = G::ZERO; + assert!(writer.pack_row(&record, &io, 0, false, &mut seed).is_err()); + seed[0] = 0; + assert!(writer.write_row(&seed, circuit, &mut row).is_err()); +} + +#[test] +fn canonical_wide_words_preserve_u128_carries() { + for value in [0, 255, 256, 1 << 32, G::ORDER_U64 - 1] { + assert_eq!(run(20, &[value; 12]), 1); + } +} + +#[test] +fn current_u64_multiply_bytecode_boundaries() { + for a in [0_u64, 1, 255, 65535, 1 << 32, u64::MAX] { + for b in [0_u64, 1, 65536, u64::MAX] { + let args: Vec<_> = a + .to_le_bytes() + .into_iter() + .chain(b.to_le_bytes()) + .map(u64::from) + .collect(); + assert_eq!(run(21, &args), 1); + } + } +} diff --git a/crates/aiur/src/trace_codegen/tests/blake3.rs b/crates/aiur/src/trace_codegen/tests/blake3.rs new file mode 100644 index 000000000..76a3cfe80 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/blake3.rs @@ -0,0 +1,27 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_0(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_0_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn pack_0_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; let [v_470]: [G; 1] = [v_462 + v_465]; let [v_471]: [G; 1] = [v_464 + v_467]; let [v_472]: [G; 1] = [v_466 + v_469]; let [v_473]: [G; 1] = [v_468 + v_463]; let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; let [v_532]: [G; 1] = [v_524 + v_527]; let [v_533]: [G; 1] = [v_526 + v_529]; let [v_534]: [G; 1] = [v_528 + v_531]; let [v_535]: [G; 1] = [v_530 + v_525]; let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; let [v_594]: [G; 1] = [v_586 + v_589]; let [v_595]: [G; 1] = [v_588 + v_591]; let [v_596]: [G; 1] = [v_590 + v_593]; let [v_597]: [G; 1] = [v_592 + v_587]; let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; let [v_656]: [G; 1] = [v_648 + v_651]; let [v_657]: [G; 1] = [v_650 + v_653]; let [v_658]: [G; 1] = [v_652 + v_655]; let [v_659]: [G; 1] = [v_654 + v_649]; let [v_660]: [G; 1] = [v_0 + v_166]; let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.check_returned::<32>(436, 0, &[v_660, v_443, v_444, v_445, v_446, v_505, v_506, v_507, v_508, v_567, v_568, v_569, v_570, v_629, v_630, v_631, v_632, v_656, v_657, v_658, v_659, v_470, v_471, v_472, v_473, v_532, v_533, v_534, v_535, v_594, v_595, v_596, v_597, v_580, v_581, v_582, v_583, v_642, v_643, v_644, v_645, v_456, v_457, v_458, v_459, v_518, v_519, v_520, v_521, v_515, v_516, v_517, v_514, v_577, v_578, v_579, v_576, v_639, v_640, v_641, v_638, v_453, v_454, v_455, v_452, 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])?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn write_0(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_0: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(0, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: true, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0()], memory_sizes: vec![], circuits: vec![Circuit { members: vec![0], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [150, 101, 248, 224, 67, 209, 56, 216, 146, 162, 51, 114, 82, 15, 10, 181, 15, 234, 113, 117, 51, 141, 70, 70, 235, 90, 62, 221, 45, 109, 215, 133], complete: true, expected: expected_program, functions: &[ +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_0, pack: pack_0, pack_typed: pack_0_typed, pack_checked: pack_0_checked, write: |seed, offsets, row| { write_0(seed, offsets, row); Ok(()) } }) +] }; diff --git a/crates/aiur/src/trace_codegen/tests/blake3_cuda.rs b/crates/aiur/src/trace_codegen/tests/blake3_cuda.rs new file mode 100644 index 000000000..fd5b356ec --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/blake3_cuda.rs @@ -0,0 +1,10 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_blake3_contract() -> *const u8; + fn aiur_trace_blake3_schema() -> *const u8; + pub(super) fn aiur_trace_blake3_0(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([150, 101, 248, 224, 67, 209, 56, 216, 146, 162, 51, 114, 82, 15, 10, 181, 15, 234, 113, 117, 51, 141, 70, 70, 235, 90, 62, 221, 45, 109, 215, 133], aiur_trace_blake3_contract, aiur_trace_blake3_schema, &[ +Some(aiur_trace_blake3_0) +], &[162], &[176]) }; diff --git a/crates/aiur/src/trace_codegen/tests/cuda.rs b/crates/aiur/src/trace_codegen/tests/cuda.rs new file mode 100644 index 000000000..791d89a97 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/cuda.rs @@ -0,0 +1,776 @@ +use super::*; +use std::sync::Arc; + +use multi_stark::{ + cuda::CudaDft, + p3_field::Field, + p3_matrix::Matrix, + witness::{TraceGenerator, TraceSource}, +}; + +use crate::trace_codegen::cuda::{prepare_memory, seed_cache_bytes}; + +pub(super) fn parity(program: &Toplevel, record: &QueryRecord, io: &IOBuffer) { + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, program).unwrap(); + let dft = CudaDft::new(0); + for (index, circuit) in program.circuits.iter().enumerate() { + let mut expected = Vec::new(); + for &member in &circuit.members { + for query in 0..record.function_queries[member].len() { + if record.function_queries[member] + .get_index(query) + .unwrap() + .1 + .multiplicity + == G::ZERO + { + continue; + } + expected.extend( + program + .main_row_for_test(index, member, query, record, io) + .into_iter() + .map(|g| g.as_canonical_u64()), + ); + } + } + if expected.is_empty() { + continue; + } + let rows = expected.len() / circuit.layout.width(); + let last = circuit.members.len() - 1; + let end = (last, record.function_queries[circuit.members[last]].len()); + let height = rows.next_power_of_two(); + let width = circuit.layout.width(); + expected.resize(height * width, 0); + // Alias checking forces the canonical codec; without it the typed codec + // is used wherever the guards pass. Both must reproduce the oracle, from + // seeds staged per tile and from seeds kept resident on the device. + for (check_aliases, retain) in + [(true, false), (false, false), (false, true)] + { + let (source, _) = bound + .prepare( + index, + record, + io, + &[], + (0, 0), + end, + rows, + check_aliases, + retain, + ) + .unwrap(); + let TraceSource::Generated(source) = source else { unreachable!() }; + let mut host = vec![G::ZERO; expected.len()]; + source.write_rows(0, &mut host); + assert_eq!( + host.iter().map(|g| g.as_canonical_u64()).collect::>(), + expected, + "circuit {index}, check_aliases {check_aliases}: CPU mirror" + ); + for (first, rows) in [(0, height), (height - 1, height + 1)] { + let actual = dft.generated_trace_rows(source.clone(), first, rows); + assert_eq!( + seed_cache_bytes(0) > 0, + retain, + "circuit {index}: seeds resident only when retained" + ); + // Goldilocks is repr(transparent) over u64. Reading raw words + // catches noncanonical device output that field equality would + // otherwise hide. + let raw = unsafe { + std::slice::from_raw_parts( + actual.values.as_ptr().cast::(), + actual.values.len(), + ) + }; + for (i, &word) in raw.iter().enumerate() { + let row = (first + i / width) % height; + assert_eq!( + word, + expected[row * width + i % width], + "circuit {index}, check_aliases {check_aliases}, row {row}, column {}", + i % width + ); + assert!(word < G::ORDER_U64); + } + } + source.release_device(0); + assert_eq!(seed_cache_bytes(0), 0, "circuit {index}: cache released"); + } + } +} + +#[test] +fn regrouping_and_frozen_seeds() { + let mut program = (generated::PROGRAM.expected)(); + program.circuits[0].members.swap(0, 1); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for (function, args) in [ + (0, vec![G::ZERO, -G::ONE]), + (3, vec![G::ONE, G::from_u8(255)]), + (12, vec![]), + ] { + program.execute_in(function, args, &mut io, &mut record).unwrap(); + } + parity(&program, &record, &io); + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare(0, &record, &io, &[], (0, 0), (3, 0), 3, true, false) + .unwrap(); + drop(record); + drop(io); + let TraceSource::Generated(source) = source else { unreachable!() }; + let expected = TraceSource::Generated(source.clone()).materialize(); + let actual = CudaDft::new(0).generated_trace_rows(source, 0, 4); + assert_eq!(actual.values, expected.values); +} + +unsafe extern "C" { + fn cudaSetDevice(device: i32) -> i32; + fn cudaMalloc(output: *mut *mut std::ffi::c_void, bytes: usize) -> i32; + fn cudaFree(output: *mut std::ffi::c_void) -> i32; + +} + +struct DeviceBuffer(*mut std::ffi::c_void); +impl DeviceBuffer { + fn new(bytes: usize) -> Self { + let mut pointer = std::ptr::null_mut(); + assert_eq!(unsafe { cudaSetDevice(0) }, 0); + assert_eq!(unsafe { cudaMalloc(&mut pointer, bytes) }, 0); + Self(pointer) + } +} +impl Drop for DeviceBuffer { + fn drop(&mut self) { + assert_eq!(unsafe { cudaFree(self.0) }, 0); + } +} + +fn synthetic_blake3(rows: usize) -> (Toplevel, QueryRecord, IOBuffer) { + let program = (blake3::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + for i in 0..rows { + let mut input = [G::ZERO; 129]; + input[0] = G::from_usize(i % 8); + for (j, value) in input[1..].iter_mut().enumerate() { + *value = G::from_usize((i * 37 + j * 19) % 256); + } + input[1] = G::from_usize(i & 255); + input[2] = G::from_usize((i >> 8) & 255); + input[3] = G::from_usize((i >> 16) & 255); + let output = [G::from_u8(42); 32]; + record.function_queries[0] + .insert( + &input, + &output, + if i % 2 == 0 { -G::ONE } else { G::from_u64(1 << 40) }, + ) + .unwrap(); + } + (program, record, io()) +} + +/// Timings of the generated BLAKE3 provider on one tile: typed against +/// canonical upload plus generation, and seed preparation against +/// materializing the same rows on the host. The retired handwritten kernel +/// measured 2.30 ms upload and 7.45 to 7.84 ms preparation on this tile. +#[test] +#[ignore = "opt-in timing of the generated BLAKE3 provider on one GPU"] +fn blake3_generated_timing() { + assert!(!cfg!(debug_assertions), "run this benchmark with --release"); + use std::{hint::black_box, time::Instant}; + const ROWS: usize = 65536; + let (program, record, io) = synthetic_blake3(ROWS); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let scalar = blake3::PROGRAM.bind(&program).unwrap(); + let writer = scalar.function(0).unwrap(); + let schema = writer.schema(); + // Multiplicity, then the stage as a full word, then 160 bytes. + assert_eq!(schema.bytes, 176); + assert_eq!(schema.offsets[1], 8); + assert!(schema.offsets[2..].iter().enumerate().all(|(i, &o)| o == 16 + i)); + let canonical_stride = SeedEncoding::Canonical.stride(schema); + let mut seed = vec![0; writer.seed_words()]; + let mut typed = vec![0; ROWS * schema.bytes]; + let mut canonical = vec![0; ROWS * canonical_stride]; + for query in 0..ROWS { + writer.pack_row(&record, &io, query, false, &mut seed).unwrap(); + SeedEncoding::Typed + .encode( + schema, + &seed, + &mut typed[query * schema.bytes..(query + 1) * schema.bytes], + ) + .unwrap(); + SeedEncoding::Canonical + .encode( + schema, + &seed, + &mut canonical + [query * canonical_stride..(query + 1) * canonical_stride], + ) + .unwrap(); + } + let output = DeviceBuffer::new(ROWS * 533 * 8); + // Canonical seeds for a whole tile exceed the staging lease, so both + // encodings are uploaded in the chunks the runtime would use for the + // wider one, keeping the launch count equal. + let chunk = (16 * 1024 * 1024 - 8) / canonical_stride; + let upload = |seeds: &[u8], stride: usize, encoding: u32, chunk: usize| { + for first in (0..ROWS).step_by(chunk) { + let rows = chunk.min(ROWS - first); + assert_eq!( + unsafe { + blake3_cuda::aiur_trace_blake3_0( + 0, + seeds[first * stride..].as_ptr(), + encoding, + rows, + rows, + 533, + 129, + 131, + output.0.cast::().add(first * 533), + ) + }, + 0 + ) + } + }; + let prepare = || { + compiled + .prepare(0, &record, &io, &[], (0, 0), (0, ROWS), ROWS, false, false) + .unwrap() + }; + let (source, _) = prepare(); + let TraceSource::Generated(source) = source else { unreachable!() }; + let mut host = vec![G::ZERO; ROWS * 533]; + // Production uploads a span as one call, so the typed tile also runs in + // the spans `prepare` would cut, as the runtime's pipeline sees them. + let span = (16 * 1024 * 1024 - 8) / schema.bytes; + println!( + "strides: canonical={canonical_stride}, typed={}, typed_span_rows={span}", + schema.bytes + ); + let mut cases: [(&str, Box); 5] = [ + ( + "upload_canonical", + Box::new(|| upload(&canonical, canonical_stride, 0, chunk)), + ), + ("upload_typed", Box::new(|| upload(&typed, schema.bytes, 1, chunk))), + ("upload_typed_span", Box::new(|| upload(&typed, schema.bytes, 1, span))), + ("cpu_rows", Box::new(|| source.write_rows(0, &mut host))), + ( + "prepare_generated", + Box::new(|| { + black_box(prepare()); + }), + ), + ]; + for (_, case) in &mut cases { + for _ in 0..2 { + case(); + } + } + let mut samples = [const { Vec::new() }; 5]; + for sample in 0..9 { + let order = if sample % 2 == 0 { [0, 1, 2, 3, 4] } else { [2, 1, 0, 4, 3] }; + for index in order { + let start = Instant::now(); + (cases[index].1)(); + samples[index].push(start.elapsed().as_secs_f64() * 1000.0); + } + } + for ((name, _), sample) in cases.iter().zip(&mut samples) { + sample.sort_by(f64::total_cmp); + println!( + "{name}: rows={ROWS}, median_ms={:.4}, samples_ms={sample:?}", + sample[4] + ); + } + println!( + "typed_over_canonical_upload={:.4}, prepare_over_cpu_rows={:.4}", + samples[1][4] / samples[0][4], + samples[4][4] / samples[3][4] + ); +} + +#[test] +fn failed_device_writer_releases_its_source() { + struct Failing; + impl TraceGenerator for Failing { + fn height(&self) -> usize { + 8 + } + fn width(&self) -> usize { + 3 + } + fn host_bytes(&self) -> usize { + 0 + } + fn write_rows(&self, _: usize, _: &mut [G]) { + unreachable!() + } + fn write_device_rows( + &self, + _: multi_stark::cuda::DeviceTraceView<'_>, + ) -> Result<(), String> { + Err("fixture failure".into()) + } + } + let source: Arc> = Arc::new(Failing); + let weak = Arc::downgrade(&source); + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + CudaDft::new(0).generate_coset_lde(source, 2, G::GENERATOR) + })); + assert!(result.is_err()); + assert!(weak.upgrade().is_none(), "failed generation leaked its source"); +} + +#[test] +fn generated_sources_and_commitments_stay_on_their_device() { + use multi_stark::{ + config::StarkGenericConfig, + types::{CommitmentParameters, FriParameters, GoldilocksBlake3Config}, + }; + let cp = CommitmentParameters { log_blowup: 2, cap_height: 0 }; + let fp = FriParameters { + log_final_poly_len: 0, + max_log_arity: 1, + num_queries: 64, + commit_proof_of_work_bits: 0, + query_proof_of_work_bits: 0, + }; + let program = (blake3::PROGRAM.expected)(); + let mut io = io(); + let mut input = vec![G::ZERO]; + input.extend((0..128).map(G::from_usize)); + let (record, _) = program.execute(0, input, &mut io).unwrap(); + let count = record.function_queries[0].len(); + assert_eq!(count, 8, "one query per BLAKE3 stage"); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let (source, _) = compiled + .prepare(0, &record, &io, &[], (0, 0), (0, count), count, false, false) + .unwrap(); + let devices: Vec = std::env::var("AIUR_TEST_GPU_DEVICES") + .unwrap_or_else(|_| "0".into()) + .split(',') + .map(|s| s.parse().unwrap()) + .collect(); + let roots = std::thread::scope(|scope| { + let handles: Vec<_> = devices + .into_iter() + .map(|device| { + let source = source.clone(); + scope.spawn(move || { + let config = + GoldilocksBlake3Config::with_device(cp, fp, Some(device)); + let domain = + multi_stark::config::Domain::::new( + G::ONE, + 3, + ) + .unwrap(); + let (root, data) = config.commit_main(vec![(domain, source.clone())]); + drop(data); + let (regenerated, data) = config.commit_main(vec![(domain, source)]); + assert_eq!(root, regenerated); + drop(data); + root + }) + }) + .collect(); + handles.into_iter().map(|h| h.join().unwrap()).collect::>() + }); + assert!(roots.windows(2).all(|pair| pair[0] == pair[1])); +} + +#[test] +fn maximum_tile_and_wrapped_halo() { + let (program, record, io) = synthetic_blake3(65537); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let (source, _) = compiled + .prepare(0, &record, &io, &[], (0, 0), (0, 65537), 65537, false, false) + .unwrap(); + let TraceSource::Generated(source) = source else { unreachable!() }; + let dft = CudaDft::new(0); + for first in [0, 65536, 131070] { + let actual = dft.generated_trace_rows(source.clone(), first, 65537); + let mut expected = vec![G::ZERO; actual.values.len()]; + source.write_rows(first, &mut expected); + for (i, (actual, expected)) in + actual.values.iter().zip(&expected).enumerate() + { + assert_eq!(actual, expected, "row {}, column {}", i / 533, i % 533); + } + } +} + +#[test] +fn resident_seeds_serve_tiles_until_released() { + const ROWS: usize = 300_000; + let (program, record, io) = synthetic_blake3(ROWS); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let prepare = |retain| { + let (source, _) = compiled + .prepare(0, &record, &io, &[], (0, 0), (0, ROWS), ROWS, false, retain) + .unwrap(); + let TraceSource::Generated(source) = source else { unreachable!() }; + source + }; + let staged = prepare(false); + let resident = prepare(true); + let dft = CudaDft::new(0); + let height = ROWS.next_power_of_two(); + assert_eq!(seed_cache_bytes(0), 0); + // The rows fill five spans, so the resident copy is one allocation + // staged through the pinned ring many times over; the first tile uploads + // it, the rest reuse it. + for (first, rows) in + [(0, 65536), (65536, 65537), (ROWS - 3, 65537), (height - 1, 2)] + { + let expected = dft.generated_trace_rows(staged.clone(), first, rows); + let actual = dft.generated_trace_rows(resident.clone(), first, rows); + assert_eq!(actual.values, expected.values, "tile at {first}"); + assert!(seed_cache_bytes(0) >= ROWS * 176, "seeds resident after {first}"); + } + let held = seed_cache_bytes(0); + resident.release_device(1); + assert_eq!(seed_cache_bytes(0), held, "another device's release is a no-op"); + resident.release_device(0); + assert_eq!(seed_cache_bytes(0), 0); + let expected = dft.generated_trace_rows(staged.clone(), 7, 9); + let actual = dft.generated_trace_rows(resident.clone(), 7, 9); + assert_eq!( + actual.values, expected.values, + "tiles are served after a release" + ); + assert_eq!(seed_cache_bytes(0), held, "and the seeds are resident again"); + drop(resident); + assert_eq!(seed_cache_bytes(0), 0, "dropping the source frees its seeds"); +} + +#[test] +fn concurrent_uploads_keep_frozen_seeds() { + let devices: Vec = std::env::var("AIUR_TEST_GPU_DEVICES") + .unwrap_or_else(|_| "0".into()) + .split(',') + .map(|x| x.parse().unwrap()) + .collect(); + let (program, record, io) = synthetic_blake3(33); + let bound = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare(0, &record, &io, &[], (0, 0), (0, 33), 33, false, false) + .unwrap(); + let TraceSource::Generated(source) = source else { unreachable!() }; + let barrier = std::sync::Barrier::new(8); + std::thread::scope(|scope| { + for worker in 0..8 { + let source = source.clone(); + let barrier = &barrier; + let device = devices[worker % devices.len()]; + scope.spawn(move || { + let dft = CudaDft::new(device); + barrier.wait(); + for first in [0, 32, 63] { + let actual = dft.generated_trace_rows(source.clone(), first, 65); + let mut expected = vec![G::ZERO; actual.values.len()]; + source.write_rows(first, &mut expected); + assert_eq!(actual.values, expected); + } + }); + } + }); +} + +#[test] +fn device_errors_release_the_staging_lease() { + let output = DeviceBuffer::new(24); + let mut seed = [0u8; 16]; + seed[0] = 1; + seed[8] = 7; + let write = |seed: &[u8; 16], encoding| unsafe { + generated_cuda::aiur_trace_fixtures_19( + 0, + seed.as_ptr(), + encoding, + 1, + 1, + 3, + 1, + 2, + output.0.cast(), + ) + }; + // More failures than staging slots detects leases stranded by an error. + for _ in 0..8 { + assert_eq!(write(&seed, 1), 10002); + } + assert_ne!(write(&seed, 2), 0); + seed[8] = 0; + assert_eq!(write(&seed, 1), 0); +} + +#[test] +fn cuda_binding_rejects_changed_seed_layout_of_the_same_size() { + // Swap the stage word and the first message byte: same words, same 176 + // bytes, consistent offsets, different layout. The kernel would read the + // packer's bytes in the wrong places, so the schema contract must reject it. + let program = (blake3::PROGRAM.expected)(); + let mut functions = blake3::PROGRAM.functions.to_vec(); + let writer = functions[0].as_mut().unwrap(); + let mut widths = writer.schema.widths.to_vec(); + widths.swap(1, 2); + let mut offsets = vec![0; widths.len()]; + let mut cursor = 0; + for width in [SeedWidth::Full, SeedWidth::U32, SeedWidth::U16, SeedWidth::U8] + { + for (i, &w) in widths.iter().enumerate() { + if w == width { + offsets[i] = cursor; + cursor += width.bytes(); + } + } + } + let schema: &'static SeedSchema = Box::leak(Box::new(SeedSchema { + widths: Box::leak(widths.into_boxed_slice()), + offsets: Box::leak(offsets.into_boxed_slice()), + bytes: writer.schema.bytes, + })); + assert!(schema.is_consistent()); + writer.schema = schema; + let changed = Box::leak(Box::new(GeneratedProgram { + fingerprint: blake3::PROGRAM.fingerprint, + complete: true, + expected: blake3::PROGRAM.expected, + functions: Box::leak(functions.into_boxed_slice()), + })); + assert!(changed.bind(&program).is_ok(), "the layout alone is well formed"); + assert_eq!( + blake3_cuda::CUDA.bind(changed, &program).err(), + Some("CUDA unit was compiled for different seed layouts") + ); +} + +#[test] +fn cuda_binding_rejects_changed_seed_width() { + let program = (blake3::PROGRAM.expected)(); + let mut functions = blake3::PROGRAM.functions.to_vec(); + functions[0].as_mut().unwrap().seed_words = 1; + let changed = Box::leak(Box::new(GeneratedProgram { + fingerprint: blake3::PROGRAM.fingerprint, + complete: true, + expected: blake3::PROGRAM.expected, + functions: Box::leak(functions.into_boxed_slice()), + })); + assert!(blake3_cuda::CUDA.bind(changed, &program).is_err()); +} + +#[test] +fn wide_rows_widen_the_member_span_once() { + // Function 3's value input is speculatively a byte. Alternating byte rows + // through the default arm and wide rows through the multiply arm must + // produce one full-width span for the whole run, matching CPU rows, + // without retaining typed reservations. + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for i in 0..1024_u64 { + let (tag, value) = + if i % 2 == 0 { (2 + i / 256, i % 256) } else { (0, (1 << 32) + i) }; + program + .execute_in( + 3, + vec![G::from_u64(tag), G::from_u64(value)], + &mut io, + &mut record, + ) + .unwrap(); + } + assert_eq!(record.function_queries[3].len(), 1024); + let circuit = circuit_of(&program, 3); + let member = + program.circuits[circuit].members.iter().position(|&f| f == 3).unwrap(); + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare( + circuit, + &record, + &io, + &[], + (member, 0), + (member, 1024), + 1024, + false, + false, + ) + .unwrap(); + let TraceSource::Generated(source) = source else { unreachable!() }; + let words = bound_words(&generated::PROGRAM, 3); + assert!(source.host_bytes() >= 1024 * 8 * words); + assert!( + source.host_bytes() < 2 * 1024 * 8 * words + 1024, + "widened span retained unused reservations: {}", + source.host_bytes() + ); + let width = program.circuits[circuit].layout.width(); + let mut expected = vec![G::ZERO; 1024 * width]; + source.write_rows(0, &mut expected); + let actual = CudaDft::new(0).generated_trace_rows(source, 0, 1024); + assert_eq!(actual.values, expected); +} + +fn bound_words(program: &GeneratedProgram, function: usize) -> usize { + program.functions[function].as_ref().unwrap().seed_words +} + +#[test] +fn wide_row_in_a_later_chunk_widens_earlier_chunks() { + // Three packing chunks of function 3 rows, all bytes except one wide value + // in the third chunk, with zero-multiplicity queries scattered through the + // run. Every chunk must end up full width, rows must keep query order with + // the dead queries skipped, and the device rows must match the oracle. + const ROWS: u64 = 3 * 4096 + 300; + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for i in 0..ROWS { + let (tag, value) = if i == 2 * 4096 + 777 { + (0, (1 << 32) + i) + } else { + (2 + i / 256, i % 256) + }; + program + .execute_in( + 3, + vec![G::from_u64(tag), G::from_u64(value)], + &mut io, + &mut record, + ) + .unwrap(); + } + assert_eq!(record.function_queries[3].len(), ROWS as usize); + for dead in [0usize, 5, 4095, 4096, 9000, ROWS as usize - 1] { + *record.function_queries[3].get_index_mut(dead).unwrap().1 = G::ZERO; + } + let live: Vec = (0..ROWS as usize) + .filter(|&q| { + record.function_queries[3].get_index(q).unwrap().1.multiplicity != G::ZERO + }) + .collect(); + let circuit = circuit_of(&program, 3); + let member = + program.circuits[circuit].members.iter().position(|&f| f == 3).unwrap(); + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare( + circuit, + &record, + &io, + &[], + (member, 0), + (member, ROWS as usize), + live.len(), + false, + false, + ) + .unwrap(); + let TraceSource::Generated(source) = source else { unreachable!() }; + let words = bound_words(&generated::PROGRAM, 3); + assert!( + source.host_bytes() >= live.len() * 8 * words, + "the whole run is full width: {}", + source.host_bytes() + ); + let width = program.circuits[circuit].layout.width(); + let height = live.len().next_power_of_two(); + let mut expected: Vec = live + .iter() + .flat_map(|&q| program.main_row_for_test(circuit, 3, q, &record, &io)) + .map(|g| g.as_canonical_u64()) + .collect(); + expected.resize(height * width, 0); + let mut host = vec![G::ZERO; height * width]; + source.write_rows(0, &mut host); + assert_eq!( + host.iter().map(|g| g.as_canonical_u64()).collect::>(), + expected, + "CPU mirror" + ); + let actual = CudaDft::new(0).generated_trace_rows(source, 0, height); + assert_eq!( + actual.values.iter().map(|g| g.as_canonical_u64()).collect::>(), + expected, + "device rows" + ); +} + +#[test] +fn memory_tables_match_the_cpu_builder() { + use crate::memory::Memory; + // Two widths, a nonzero pointer namespace, zero and negative + // multiplicities, and ranges that start past the table's first entry. + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::with_pointer_base(&program, 1 << 30); + for (width, entries) in [(2usize, 300usize), (10, 4097)] { + let table = record.memory_queries.get_mut(&width).unwrap(); + for i in 0..entries { + let values: Vec = (0..width) + .map(|j| G::from_u64(((i * 977 + j * 131) as u64) << 40 | i as u64)) + .collect(); + let multiplicity = match i % 3 { + 0 => G::ZERO, + 1 => -G::from_usize(i), + _ => G::from_usize(i), + }; + table + .insert( + &values, + &[G::from_usize(record.pointer_base + i)], + multiplicity, + ) + .unwrap(); + } + } + let dft = CudaDft::new(0); + for (width, ranges) in [ + (2usize, vec![0..300, 5..300, 299..300]), + (10, vec![0..4097, 4096..4097, 13..2000]), + ] { + for range in ranges { + let (expected, _) = + Memory::witness_data_range(width, &record, &[], range.clone()); + let (source, _) = + prepare_memory(&record, width, &[], range.clone()).unwrap(); + let TraceSource::Generated(source) = source else { unreachable!() }; + assert_eq!(source.height(), expected.height()); + let mut host = vec![G::ZERO; expected.values.len()]; + source.write_rows(0, &mut host); + assert_eq!( + host, expected.values, + "width {width}, range {range:?}: CPU mirror" + ); + let height = expected.height(); + for (first, rows) in [(0, height), (height - 1, height + 1)] { + let actual = dft.generated_trace_rows(source.clone(), first, rows); + let w = width + 3; + for (i, cell) in actual.values.iter().enumerate() { + let row = (first + i / w) % height; + assert_eq!( + *cell, + expected.values[row * w + i % w], + "width {width}, range {range:?}, row {row}, column {}", + i % w + ); + } + } + } + } + assert!(prepare_memory(&record, 2, &[], 0..0).is_err()); + assert!(prepare_memory(&record, 2, &[], 0..301).is_err()); +} diff --git a/crates/aiur/src/trace_codegen/tests/generated.rs b/crates/aiur/src/trace_codegen/tests/generated.rs new file mode 100644 index 000000000..ab815d572 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/generated.rs @@ -0,0 +1,353 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_0(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_0_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_0_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn write_0(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_4]: [G; 1] = [v_0 * v_1]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(7)]; let [v_6]: [G; 1] = [v_4 * v_5]; let [v_7]: [G; 1] = [G::from_bool(v_6.is_zero())]; row[offsets.auxiliaries + 2] = g_inverse_value(v_6).as_canonical_u64(); row[offsets.auxiliaries + 3] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_bool(v_0.is_zero())]; row[offsets.auxiliaries + 4] = g_inverse_value(v_0).as_canonical_u64(); row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); let [v_9]: [G; 1] = [g_inverse_value(v_0)]; row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 8] = v_0.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_0: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_1(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_1_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_1_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn write_1(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9]: [G; 8] = [G::from_bool((v_0.as_canonical_u64() & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); let [v_10]: [G; 1] = [Bytes1::shift_left(&v_0)]; row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [Bytes1::shift_right(&v_0)]; row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = [Bytes2::xor(&v_0, &v_1)]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); let op_4 = Bytes2::add(&v_0, &v_1); let [v_13, v_14]: [G; 2] = [op_4.0, op_4.1]; row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); let op_5 = Bytes2::sub(&v_0, &v_1); let [v_15, v_16]: [G; 2] = [op_5.0, op_5.1]; row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); let op_6 = Bytes2::mul(&v_0, &v_1); let [v_17, v_18]: [G; 2] = [op_6.0, op_6.1]; row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [Bytes2::and(&v_0, &v_1)]; row[offsets.auxiliaries + 16] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [Bytes2::or(&v_0, &v_1)]; row[offsets.auxiliaries + 17] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [Bytes2::less_than(&v_0, &v_1)]; row[offsets.auxiliaries + 18] = v_21.as_canonical_u64(); let op_10 = Bytes2::xor_split7(&v_0, &v_1); let [v_22, v_23]: [G; 2] = [op_10.0, op_10.1]; row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_23.as_canonical_u64(); let op_11 = Bytes2::xor_split4(&v_0, &v_1); let [v_24, v_25]: [G; 2] = [op_11.0, op_11.1]; row[offsets.auxiliaries + 21] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [v_14 * v_16]; row[offsets.auxiliaries + 23] = v_26.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_1: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9], bytes: 16 }; + +fn pack_2(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn pack_2_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn pack_2_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn write_2(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let [v_12]: [G; 1] = [G::from_u64(u32_word([v_0, v_1, v_2, v_3]))]; let [v_13]: [G; 1] = [G::from_u64(u32_word([v_4, v_5, v_6, v_7]))]; let op_2 = u32_less_than(v_12, v_13); let [v_14]: [G; 1] = [op_2.0]; row[offsets.auxiliaries + 1] = op_2.1[0].as_canonical_u64(); row[offsets.auxiliaries + 2] = op_2.1[1].as_canonical_u64(); row[offsets.auxiliaries + 3] = op_2.1[2].as_canonical_u64(); row[offsets.auxiliaries + 4] = op_2.1[3].as_canonical_u64(); row[offsets.auxiliaries + 5] = op_2.1[4].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_2.1[5].as_canonical_u64(); let [v_15, v_16, v_17, v_18, v_19]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7])]); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); let [v_20, v_21, v_22, v_23, v_24]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7]), u32_word([v_8, v_9, v_10, v_11])]); row[offsets.auxiliaries + 11] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_23.as_canonical_u64(); let [v_25]: [G; 1] = [v_19 * v_24]; row[offsets.auxiliaries + 15] = v_25.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_2: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], bytes: 24 }; + +fn pack_3(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_3_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_3_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn write_3(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_2]: [G; 1] = [v_1 * v_1]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_2]; }, 1u64 => { let op_1 = Bytes2::add(&v_1, &v_1); let [v_3, v_4]: [G; 2] = [op_1.0, op_1.1]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 2] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_5]: [G; 1] = [G::from_bool(v_1.is_zero())]; row[offsets.auxiliaries + 3] = g_inverse_value(v_1).as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_5]; }, } }; row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [v_6 * v_1]; row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); } + +static SCHEMA_3: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_4(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let [v_2]: [G; 1] = context.store(1, &[v_0, v_1])?; seed[2] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = context.call::<1>(2, 5, &[v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = context.load::<2>(3, v_3)?; seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_4_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let [v_2]: [G; 1] = context.store(1, &[v_0, v_1])?; seed.u32(32, v_2); let [v_3]: [G; 1] = context.call::<1>(2, 5, &[v_2])?; seed.u32(36, v_3); let [v_4, v_5]: [G; 2] = context.load::<2>(3, v_3)?; seed.full(16, v_4); seed.full(24, v_5); Ok(()) } + +fn pack_4_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let [v_2]: [G; 1] = context.store(1, &[v_0, v_1])?; seed[2] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = context.call::<1>(2, 5, &[v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = context.load::<2>(3, v_3)?; seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); Ok(()) } + +fn write_4(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_4: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 32, 36, 16, 24], bytes: 40 }; + +fn pack_5(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn pack_5_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; } + +fn pack_5_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn write_5(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_5: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8], bytes: 16 }; + +fn pack_6(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_2]: [G; 1] = context.returned::<1>(1)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn pack_6_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_2]: [G; 1] = context.returned::<1>(1)?; seed.full(16, v_2); Ok(()) } + +fn pack_6_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let [v_2]: [G; 1] = context.check_returned::<1>(1, 5, &[v_1])?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn write_6(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_6: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_7(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.io_info(1, v_0, &[v_1])?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_0, v_2)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_7_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.io_info(1, v_0, &[v_1])?; seed.u32(40, v_2); seed.u32(44, v_3); let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_0, v_2)?; seed.full(24, v_4); seed.full(32, v_5); Ok(()) } + +fn pack_7_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.io_info(1, v_0, &[v_1])?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_0, v_2)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); Ok(()) } + +fn write_7(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3]: [G; 2] = [G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_7: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 40, 44, 24, 32], bytes: 48 }; + +fn pack_8(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn pack_8_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed.full(8, v_2); Ok(()) } + +fn pack_8_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn write_8(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); return; }, _ => { row[offsets.auxiliaries + 2] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 3] = v_2.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); } + +static SCHEMA_8: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 16, 8], bytes: 24 }; + +fn pack_9(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_1]: [G; 1] = [v_0 * v_0]; match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn pack_9_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_1]: [G; 1] = [v_0 * v_0]; match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed.full(8, v_2); Ok(()) } + +fn pack_9_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_1]: [G; 1] = [v_0 * v_0]; match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn write_9(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); return; }, _ => { row[offsets.auxiliaries + 2] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 3] = v_2.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); } + +static SCHEMA_9: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 16, 8], bytes: 24 }; + +fn pack_10(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = context.io_read::<1>(1, v_1, v_2)?; seed[3] = v_3.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_1, v_2)?; seed[3] = v_4.as_canonical_u64(); seed[4] = v_5.as_canonical_u64(); break 'yield_0 [v_5]; }, } }; let [v_7]: [G; 1] = context.io_read::<1>(3, v_1, v_6)?; seed[5] = v_7.as_canonical_u64(); Ok(()) } + +fn pack_10_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = context.io_read::<1>(1, v_1, v_2)?; seed.full(24, v_3); break 'yield_0 [v_3]; }, _ => { let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_1, v_2)?; seed.full(24, v_4); seed.u32(40, v_5); break 'yield_0 [v_5]; }, } }; let [v_7]: [G; 1] = context.io_read::<1>(3, v_1, v_6)?; seed.full(32, v_7); Ok(()) } + +fn pack_10_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = context.io_read::<1>(1, v_1, v_2)?; seed[3] = v_3.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_1, v_2)?; seed[3] = v_4.as_canonical_u64(); seed[4] = v_5.as_canonical_u64(); break 'yield_0 [v_5]; }, } }; let [v_7]: [G; 1] = context.io_read::<1>(3, v_1, v_6)?; seed[5] = v_7.as_canonical_u64(); Ok(()) } + +fn write_10(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_5]; }, } }; row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); } + +static SCHEMA_10: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 8, 16, 24, 40, 32], bytes: 48 }; + +fn pack_11(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.big_uint(0, v_0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13]: [G; 10] = context.load::<10>(1, v_2)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); Ok(()) } + +fn pack_11_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.big_uint(0, v_0, v_1)?; seed.u32(104, v_2); seed.u32(108, v_3); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13]: [G; 10] = context.load::<10>(1, v_2)?; seed.full(24, v_4); seed.full(32, v_5); seed.full(40, v_6); seed.full(48, v_7); seed.full(56, v_8); seed.full(64, v_9); seed.full(72, v_10); seed.full(80, v_11); seed.full(88, v_12); seed.full(96, v_13); Ok(()) } + +fn pack_11_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.big_uint(0, v_0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13]: [G; 10] = context.load::<10>(1, v_2)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); Ok(()) } + +fn write_11(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3]: [G; 2] = [G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13]: [G; 10] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_11: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 104, 108, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96], bytes: 112 }; + +fn pack_12(context: &SeedContext<'_>, seed: &mut [u64],) { } + +fn pack_12_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { } + +fn pack_12_checked(context: &SeedContext<'_>, seed: &mut [u64],) { } + +fn write_12(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_12: SeedSchema = SeedSchema { widths: &[SeedWidth::Full], offsets: &[0], bytes: 8 }; + +fn pack_14(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.returned::<1>(0)?; seed[2] = v_1.as_canonical_u64(); Ok(()) } + +fn pack_14_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.returned::<1>(0)?; seed.full(16, v_1); Ok(()) } + +fn pack_14_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.check_returned::<1>(0, 13, &[v_0])?; seed[2] = v_1.as_canonical_u64(); Ok(()) } + +fn write_14(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_14: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_15(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn pack_15_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; } + +fn pack_15_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn write_15(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_15: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32], offsets: &[0, 8], bytes: 16 }; + +fn pack_16(context: &SeedContext<'_>, seed: &mut [u64],) { } + +fn pack_16_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { } + +fn pack_16_checked(context: &SeedContext<'_>, seed: &mut [u64],) { } + +fn write_16(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_16: SeedSchema = SeedSchema { widths: &[SeedWidth::Full], offsets: &[0], bytes: 8 }; + +fn pack_17(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_17_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn pack_17_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; let [v_470]: [G; 1] = [v_462 + v_465]; let [v_471]: [G; 1] = [v_464 + v_467]; let [v_472]: [G; 1] = [v_466 + v_469]; let [v_473]: [G; 1] = [v_468 + v_463]; let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; let [v_532]: [G; 1] = [v_524 + v_527]; let [v_533]: [G; 1] = [v_526 + v_529]; let [v_534]: [G; 1] = [v_528 + v_531]; let [v_535]: [G; 1] = [v_530 + v_525]; let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; let [v_594]: [G; 1] = [v_586 + v_589]; let [v_595]: [G; 1] = [v_588 + v_591]; let [v_596]: [G; 1] = [v_590 + v_593]; let [v_597]: [G; 1] = [v_592 + v_587]; let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; let [v_656]: [G; 1] = [v_648 + v_651]; let [v_657]: [G; 1] = [v_650 + v_653]; let [v_658]: [G; 1] = [v_652 + v_655]; let [v_659]: [G; 1] = [v_654 + v_649]; let [v_660]: [G; 1] = [v_0 + v_166]; let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.check_returned::<32>(436, 17, &[v_660, v_443, v_444, v_445, v_446, v_505, v_506, v_507, v_508, v_567, v_568, v_569, v_570, v_629, v_630, v_631, v_632, v_656, v_657, v_658, v_659, v_470, v_471, v_472, v_473, v_532, v_533, v_534, v_535, v_594, v_595, v_596, v_597, v_580, v_581, v_582, v_583, v_642, v_643, v_644, v_645, v_456, v_457, v_458, v_459, v_518, v_519, v_520, v_521, v_515, v_516, v_517, v_514, v_577, v_578, v_579, v_576, v_639, v_640, v_641, v_638, v_453, v_454, v_455, v_452, 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])?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn write_17(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_17: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_18(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_8]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = 'yield_1: { match v_2.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; break 'yield_1 [v_3]; }, _ => { let [v_4]: [G; 1] = [G::from_u64(1)]; break 'yield_1 [v_4]; }, } }; let [v_6]: [G; 1] = [v_5 + v_2]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = [G::from_u64(2)]; break 'yield_0 [v_7]; }, } }; let [v_9]: [G; 1] = context.io_read::<1>(4, v_1, v_8)?; seed[4] = v_9.as_canonical_u64(); Ok(()) } + +fn pack_18_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_8]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = 'yield_1: { match v_2.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; break 'yield_1 [v_3]; }, _ => { let [v_4]: [G; 1] = [G::from_u64(1)]; break 'yield_1 [v_4]; }, } }; let [v_6]: [G; 1] = [v_5 + v_2]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = [G::from_u64(2)]; break 'yield_0 [v_7]; }, } }; let [v_9]: [G; 1] = context.io_read::<1>(4, v_1, v_8)?; seed.full(32, v_9); Ok(()) } + +fn pack_18_checked(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_8]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = 'yield_1: { match v_2.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; break 'yield_1 [v_3]; }, _ => { let [v_4]: [G; 1] = [G::from_u64(1)]; break 'yield_1 [v_4]; }, } }; let [v_6]: [G; 1] = [v_5 + v_2]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = [G::from_u64(2)]; break 'yield_0 [v_7]; }, } }; let [v_9]: [G; 1] = context.io_read::<1>(4, v_1, v_8)?; seed[4] = v_9.as_canonical_u64(); Ok(()) } + +fn write_18(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_8]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = 'yield_1: { match v_2.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_1 [v_3]; }, _ => { row[offsets.auxiliaries + 1] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_1 [v_4]; }, } }; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); let [v_6]: [G; 1] = [v_5 + v_2]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_6]; }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(2)]; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_7]; }, } }; row[offsets.auxiliaries + 3] = v_8.as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); } + +static SCHEMA_18: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 24, 32], bytes: 40 }; + +fn pack_19(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn pack_19_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; } + +fn pack_19_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn write_19(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); match v_0.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(19, v_0)) }, } } + +static SCHEMA_19: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8], offsets: &[0, 8], bytes: 16 }; + +fn pack_20(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn pack_20_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn pack_20_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn write_20(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let [v_12, v_13, v_14, v_15, v_16]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7])]); row[offsets.auxiliaries + 1] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_15.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7]), u32_word([v_8, v_9, v_10, v_11])]); row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_20.as_canonical_u64(); let [v_22]: [G; 1] = [v_16 * v_21]; row[offsets.auxiliaries + 9] = v_22.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_20: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], bytes: 24 }; + +fn pack_21(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_21_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_21_checked(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn write_21(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_16]: [G; 1] = [G::from_u64(256)]; let [v_17]: [G; 1] = [v_16 * v_1]; let [v_18]: [G; 1] = [v_0 + v_17]; let [v_19]: [G; 1] = [v_16 * v_9]; let [v_20]: [G; 1] = [v_8 + v_19]; let [v_21]: [G; 1] = [v_16 * v_3]; let [v_22]: [G; 1] = [v_2 + v_21]; let [v_23]: [G; 1] = [v_16 * v_11]; let [v_24]: [G; 1] = [v_10 + v_23]; let [v_25]: [G; 1] = [v_16 * v_5]; let [v_26]: [G; 1] = [v_4 + v_25]; let [v_27]: [G; 1] = [v_16 * v_13]; let [v_28]: [G; 1] = [v_12 + v_27]; let [v_29]: [G; 1] = [v_16 * v_7]; let [v_30]: [G; 1] = [v_6 + v_29]; let [v_31]: [G; 1] = [v_16 * v_15]; let [v_32]: [G; 1] = [v_14 + v_31]; let [v_33]: [G; 1] = [v_18 * v_20]; row[offsets.auxiliaries + 1] = v_33.as_canonical_u64(); let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41]: [G; 8] = v_33.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 2] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_41.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(65536)]; let [v_45]: [G; 1] = [v_16 * v_37]; let [v_46]: [G; 1] = [v_44 * v_38]; let [v_47]: [G; 1] = [v_45 + v_46]; let [v_48]: [G; 1] = [v_36 + v_47]; let [v_52]: [G; 1] = [v_18 * v_24]; row[offsets.auxiliaries + 10] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [v_22 * v_20]; row[offsets.auxiliaries + 11] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [v_53 + v_48]; let [v_55]: [G; 1] = [v_52 + v_54]; let [v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 8] = v_55.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 12] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_63.as_canonical_u64(); let [v_65]: [G; 1] = [v_16 * v_59]; let [v_66]: [G; 1] = [v_44 * v_60]; let [v_67]: [G; 1] = [v_65 + v_66]; let [v_68]: [G; 1] = [v_58 + v_67]; let [v_72]: [G; 1] = [v_18 * v_28]; row[offsets.auxiliaries + 20] = v_72.as_canonical_u64(); let [v_73]: [G; 1] = [v_22 * v_24]; row[offsets.auxiliaries + 21] = v_73.as_canonical_u64(); let [v_74]: [G; 1] = [v_26 * v_20]; row[offsets.auxiliaries + 22] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = [v_74 + v_68]; let [v_76]: [G; 1] = [v_73 + v_75]; let [v_77]: [G; 1] = [v_72 + v_76]; let [v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 8] = v_77.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 23] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_85.as_canonical_u64(); let [v_87]: [G; 1] = [v_16 * v_81]; let [v_88]: [G; 1] = [v_44 * v_82]; let [v_89]: [G; 1] = [v_87 + v_88]; let [v_90]: [G; 1] = [v_80 + v_89]; let [v_94]: [G; 1] = [v_18 * v_32]; row[offsets.auxiliaries + 31] = v_94.as_canonical_u64(); let [v_95]: [G; 1] = [v_22 * v_28]; row[offsets.auxiliaries + 32] = v_95.as_canonical_u64(); let [v_96]: [G; 1] = [v_26 * v_24]; row[offsets.auxiliaries + 33] = v_96.as_canonical_u64(); let [v_97]: [G; 1] = [v_30 * v_20]; row[offsets.auxiliaries + 34] = v_97.as_canonical_u64(); let [v_98]: [G; 1] = [v_97 + v_90]; let [v_99]: [G; 1] = [v_96 + v_98]; let [v_100]: [G; 1] = [v_95 + v_99]; let [v_101]: [G; 1] = [v_94 + v_100]; let [v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109]: [G; 8] = v_101.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 35] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_109.as_canonical_u64(); let [v_111]: [G; 1] = [v_16 * v_105]; let [v_112]: [G; 1] = [v_44 * v_106]; let [v_113]: [G; 1] = [v_111 + v_112]; let [v_114]: [G; 1] = [v_104 + v_113]; let [v_118]: [G; 1] = [v_22 * v_32]; row[offsets.auxiliaries + 43] = v_118.as_canonical_u64(); let [v_119]: [G; 1] = [v_26 * v_28]; row[offsets.auxiliaries + 44] = v_119.as_canonical_u64(); let [v_120]: [G; 1] = [v_30 * v_24]; row[offsets.auxiliaries + 45] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = [v_120 + v_114]; let [v_122]: [G; 1] = [v_119 + v_121]; let [v_123]: [G; 1] = [v_118 + v_122]; let [v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131]: [G; 8] = v_123.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 46] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_131.as_canonical_u64(); let [v_133]: [G; 1] = [v_16 * v_127]; let [v_134]: [G; 1] = [v_44 * v_128]; let [v_135]: [G; 1] = [v_133 + v_134]; let [v_136]: [G; 1] = [v_126 + v_135]; let [v_140]: [G; 1] = [v_26 * v_32]; row[offsets.auxiliaries + 54] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [v_30 * v_28]; row[offsets.auxiliaries + 55] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [v_141 + v_136]; let [v_143]: [G; 1] = [v_140 + v_142]; let [v_144, v_145, v_146, v_147, v_148, v_149, v_150, v_151]: [G; 8] = v_143.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 56] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_151.as_canonical_u64(); let [v_153]: [G; 1] = [v_16 * v_147]; let [v_154]: [G; 1] = [v_44 * v_148]; let [v_155]: [G; 1] = [v_153 + v_154]; let [v_156]: [G; 1] = [v_146 + v_155]; let [v_160]: [G; 1] = [v_30 * v_32]; row[offsets.auxiliaries + 64] = v_160.as_canonical_u64(); let [v_161]: [G; 1] = [v_160 + v_156]; let [v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 8] = v_161.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 65] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_169.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_21: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128], bytes: 136 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::Add(0, 1), Op::Sub(0, 1), Op::Mul(0, 1), Op::Const(G::from_u64(7)), Op::Mul(4, 5), Op::EqZero(6), Op::EqZero(0), Op::UnconstrainedGInverse(0), Op::UnconstrainedGToBytes(0)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![Op::U8BitDecomposition(0), Op::U8ShiftLeft(0), Op::U8ShiftRight(0), Op::U8Xor(0, 1), Op::U8Add(0, 1), Op::U8Sub(0, 1), Op::U8Mul(0, 1), Op::U8And(0, 1), Op::U8Or(0, 1), Op::U8LessThan(0, 1), Op::U8XorSplit7(0, 1), Op::U8XorSplit4(0, 1), Op::U8RangeCheck(0, 1), Op::Mul(14, 16)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 24, lookups: 14 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![Op::U32ToField(vec![0, 1, 2, 3]), Op::U32ToField(vec![4, 5, 6, 7]), Op::U32LessThan(12, 13), Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::Mul(19, 24)], ctrl: Ctrl::Return(0, vec![12, 13, 14, 19, 24]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 16, lookups: 7 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Mul(1, 1)], ctrl: Ctrl::Yield(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::U8Add(1, 1)], ctrl: Ctrl::Yield(1, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::EqZero(1)], ctrl: Ctrl::Yield(2, vec![2]) })), 1, 4, 1, Box::new(Block { ops: vec![Op::Mul(2, 1)], ctrl: Ctrl::Return(3, vec![3]) })) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Store(vec![0, 1]), Op::Call(5, vec![2], 1, false), Op::Load(2, 3), Op::Add(4, 5)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Call(5, vec![1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![Op::IOWrite(0, vec![1]), Op::IOGetInfo(0, vec![1]), Op::IORead(0, 2, 2), Op::Const(G::from_u64(999)), Op::IOSetInfo(0, vec![6], 2, 3), Op::AssertEq(vec![4], vec![4], Some("quoted \"value\"\nλ".into())), Op::Debug("trace fixture".into(), None)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0)], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 0, Box::new(Block { ops: vec![Op::Load(1, 0)], ctrl: Ctrl::Return(2, vec![]) })) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 4, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Mul(0, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 2, 0, Box::new(Block { ops: vec![Op::Load(1, 0)], ctrl: Ctrl::Return(3, vec![]) })) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 4, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::IORead(1, 2, 1)], ctrl: Ctrl::Yield(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::IORead(1, 2, 2)], ctrl: Ctrl::Yield(1, vec![4]) })), 1, 3, 0, Box::new(Block { ops: vec![Op::IORead(1, 3, 1)], ctrl: Ctrl::Return(2, vec![4]) })) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedBigUintDivMod(0, 1), Op::Load(10, 2)], ctrl: Ctrl::Return(0, vec![2, 3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 13, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::EqZero(0), Op::Const(G::from_u64(18446744069414584320)), Op::EqZero(2)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGInverse(0)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: true, constrained: false } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::Call(13, vec![0], 1, true)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Call(16, vec![], 0, false), Op::Load(0, 0), Op::IORead(0, 0, 0)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(17, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![3]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Add(3, 2)], ctrl: Ctrl::Yield(2, vec![4]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(3, vec![3]) })), 1, 2, 0, Box::new(Block { ops: vec![Op::IORead(1, 3, 1)], ctrl: Ctrl::Return(4, vec![4]) })) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 5, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::Mul(16, 21)], ctrl: Ctrl::Return(0, vec![16, 21, 22]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 10, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 1), Op::Add(0, 17), Op::Mul(16, 9), Op::Add(8, 19), Op::Mul(16, 3), Op::Add(2, 21), Op::Mul(16, 11), Op::Add(10, 23), Op::Mul(16, 5), Op::Add(4, 25), Op::Mul(16, 13), Op::Add(12, 27), Op::Mul(16, 7), Op::Add(6, 29), Op::Mul(16, 15), Op::Add(14, 31), Op::Mul(18, 20), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(34, 35), Op::U8RangeCheck(36, 37), Op::Const(G::from_u64(0)), Op::U8RangeCheck(38, 42), Op::Mul(16, 35), Op::Const(G::from_u64(65536)), Op::Mul(16, 37), Op::Mul(44, 38), Op::Add(45, 46), Op::Add(36, 47), Op::Mul(44, 48), Op::Add(43, 49), Op::Add(34, 50), Op::AssertEq(vec![33], vec![51], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 24), Op::Mul(22, 20), Op::Add(53, 48), Op::Add(52, 54), Op::UnconstrainedGToBytes(55), Op::U8RangeCheck(56, 57), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 42), Op::Mul(16, 57), Op::Mul(16, 59), Op::Mul(44, 60), Op::Add(65, 66), Op::Add(58, 67), Op::Mul(44, 68), Op::Add(64, 69), Op::Add(56, 70), Op::AssertEq(vec![55], vec![71], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 28), Op::Mul(22, 24), Op::Mul(26, 20), Op::Add(74, 68), Op::Add(73, 75), Op::Add(72, 76), Op::UnconstrainedGToBytes(77), Op::U8RangeCheck(78, 79), Op::U8RangeCheck(80, 81), Op::U8RangeCheck(82, 42), Op::Mul(16, 79), Op::Mul(16, 81), Op::Mul(44, 82), Op::Add(87, 88), Op::Add(80, 89), Op::Mul(44, 90), Op::Add(86, 91), Op::Add(78, 92), Op::AssertEq(vec![77], vec![93], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 32), Op::Mul(22, 28), Op::Mul(26, 24), Op::Mul(30, 20), Op::Add(97, 90), Op::Add(96, 98), Op::Add(95, 99), Op::Add(94, 100), Op::UnconstrainedGToBytes(101), Op::U8RangeCheck(102, 103), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 42), Op::Mul(16, 103), Op::Mul(16, 105), Op::Mul(44, 106), Op::Add(111, 112), Op::Add(104, 113), Op::Mul(44, 114), Op::Add(110, 115), Op::Add(102, 116), Op::AssertEq(vec![101], vec![117], Some("u64_mul: column hint does not recompose".into())), Op::Mul(22, 32), Op::Mul(26, 28), Op::Mul(30, 24), Op::Add(120, 114), Op::Add(119, 121), Op::Add(118, 122), Op::UnconstrainedGToBytes(123), Op::U8RangeCheck(124, 125), Op::U8RangeCheck(126, 127), Op::U8RangeCheck(128, 42), Op::Mul(16, 125), Op::Mul(16, 127), Op::Mul(44, 128), Op::Add(133, 134), Op::Add(126, 135), Op::Mul(44, 136), Op::Add(132, 137), Op::Add(124, 138), Op::AssertEq(vec![123], vec![139], Some("u64_mul: column hint does not recompose".into())), Op::Mul(26, 32), Op::Mul(30, 28), Op::Add(141, 136), Op::Add(140, 142), Op::UnconstrainedGToBytes(143), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::U8RangeCheck(148, 42), Op::Mul(16, 145), Op::Mul(16, 147), Op::Mul(44, 148), Op::Add(153, 154), Op::Add(146, 155), Op::Mul(44, 156), Op::Add(152, 157), Op::Add(144, 158), Op::AssertEq(vec![143], vec![159], Some("u64_mul: column hint does not recompose".into())), Op::Mul(30, 32), Op::Add(160, 156), Op::UnconstrainedGToBytes(161), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::U8RangeCheck(166, 42), Op::Mul(16, 163), Op::Mul(16, 165), Op::Mul(44, 166), Op::Add(171, 172), Op::Add(164, 173), Op::Mul(44, 174), Op::Add(170, 175), Op::Add(162, 176), Op::AssertEq(vec![161], vec![177], Some("u64_mul: column hint does not recompose".into())), Op::AssertEq(vec![166], vec![42], Some("u64_mul: final carry exceeds one radix digit".into()))], ctrl: Ctrl::Return(0, vec![34, 35, 56, 57, 78, 79, 102, 103, 124, 125, 144, 145, 162, 163, 164, 165]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 }, entry: true, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21()], memory_sizes: vec![0, 1, 2, 10], circuits: vec![Circuit { members: vec![0, 3, 12], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 15, lookups: 2 } }, Circuit { members: vec![1], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 24, lookups: 14 } }, Circuit { members: vec![2], layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 16, lookups: 7 } }, Circuit { members: vec![4], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![5], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![6], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![7], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 1 } }, Circuit { members: vec![8], layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![9], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![10], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 1 } }, Circuit { members: vec![11], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 13, lookups: 2 } }, Circuit { members: vec![14], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![15], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 3 } }, Circuit { members: vec![16], layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![17], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![18], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 5, lookups: 1 } }, Circuit { members: vec![19], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![20], layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 10, lookups: 1 } }, Circuit { members: vec![21], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [213, 235, 108, 220, 115, 159, 51, 229, 206, 4, 193, 234, 222, 143, 95, 162, 130, 93, 210, 36, 144, 208, 151, 97, 95, 24, 25, 23, 225, 30, 236, 67], complete: true, expected: expected_program, functions: &[ +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 1 }, output_size: 0, seed_words: 3, schema: &SCHEMA_0, pack: |context, seed| { pack_0(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_0_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_0_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_0(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 24, lookups: 14 }, output_size: 0, seed_words: 3, schema: &SCHEMA_1, pack: |context, seed| { pack_1(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_1_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_1_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_1(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 16, lookups: 7 }, output_size: 5, seed_words: 13, schema: &SCHEMA_2, pack: |context, seed| { pack_2(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_2_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_2_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_2(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 2 }, output_size: 1, seed_words: 3, schema: &SCHEMA_3, pack: |context, seed| { pack_3(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_3_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_3_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_3(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 6, schema: &SCHEMA_4, pack: pack_4, pack_typed: pack_4_typed, pack_checked: pack_4_checked, write: |seed, offsets, row| { write_4(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 1, seed_words: 2, schema: &SCHEMA_5, pack: |context, seed| { pack_5(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_5_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_5_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_5(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, output_size: 1, seed_words: 3, schema: &SCHEMA_6, pack: pack_6, pack_typed: pack_6_typed, pack_checked: pack_6_checked, write: |seed, offsets, row| { write_6(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 1 }, output_size: 2, seed_words: 7, schema: &SCHEMA_7, pack: pack_7, pack_typed: pack_7_typed, pack_checked: pack_7_checked, write: |seed, offsets, row| { write_7(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 4, lookups: 2 }, output_size: 0, seed_words: 3, schema: &SCHEMA_8, pack: pack_8, pack_typed: pack_8_typed, pack_checked: pack_8_checked, write: |seed, offsets, row| { write_8(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 4, lookups: 2 }, output_size: 0, seed_words: 3, schema: &SCHEMA_9, pack: pack_9, pack_typed: pack_9_typed, pack_checked: pack_9_checked, write: |seed, offsets, row| { write_9(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 1 }, output_size: 1, seed_words: 6, schema: &SCHEMA_10, pack: pack_10, pack_typed: pack_10_typed, pack_checked: pack_10_checked, write: |seed, offsets, row| { write_10(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 13, lookups: 2 }, output_size: 2, seed_words: 15, schema: &SCHEMA_11, pack: pack_11, pack_typed: pack_11_typed, pack_checked: pack_11_checked, write: |seed, offsets, row| { write_11(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 0, seed_words: 1, schema: &SCHEMA_12, pack: |context, seed| { pack_12(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_12_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_12_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_12(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, output_size: 1, seed_words: 3, schema: &SCHEMA_14, pack: pack_14, pack_typed: pack_14_typed, pack_checked: pack_14_checked, write: |seed, offsets, row| { write_14(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 3 }, output_size: 0, seed_words: 2, schema: &SCHEMA_15, pack: |context, seed| { pack_15(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_15_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_15_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_15(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 0, seed_words: 1, schema: &SCHEMA_16, pack: |context, seed| { pack_16(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_16_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_16_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_16(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_17, pack: pack_17, pack_typed: pack_17_typed, pack_checked: pack_17_checked, write: |seed, offsets, row| { write_17(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 5, lookups: 1 }, output_size: 1, seed_words: 5, schema: &SCHEMA_18, pack: pack_18, pack_typed: pack_18_typed, pack_checked: pack_18_checked, write: |seed, offsets, row| { write_18(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 0, seed_words: 2, schema: &SCHEMA_19, pack: |context, seed| { pack_19(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_19_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_19_checked(context, seed); Ok(()) }, write: write_19 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 10, lookups: 1 }, output_size: 3, seed_words: 13, schema: &SCHEMA_20, pack: |context, seed| { pack_20(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_20_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_20_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_20(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 }, output_size: 16, seed_words: 17, schema: &SCHEMA_21, pack: |context, seed| { pack_21(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_21_typed(context, seed); Ok(()) }, pack_checked: |context, seed| { pack_21_checked(context, seed); Ok(()) }, write: |seed, offsets, row| { write_21(seed, offsets, row); Ok(()) } }) +] }; diff --git a/crates/aiur/src/trace_codegen/tests/generated_cuda.rs b/crates/aiur/src/trace_codegen/tests/generated_cuda.rs new file mode 100644 index 000000000..3e1a122c5 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/generated_cuda.rs @@ -0,0 +1,51 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_fixtures_contract() -> *const u8; + fn aiur_trace_fixtures_schema() -> *const u8; + pub(super) fn aiur_trace_fixtures_0(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_1(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_2(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_3(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_4(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_5(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_6(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_7(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_8(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_9(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_10(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_11(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_12(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_14(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_15(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_16(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_17(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_18(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_19(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_20(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_21(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([213, 235, 108, 220, 115, 159, 51, 229, 206, 4, 193, 234, 222, 143, 95, 162, 130, 93, 210, 36, 144, 208, 151, 97, 95, 24, 25, 23, 225, 30, 236, 67], aiur_trace_fixtures_contract, aiur_trace_fixtures_schema, &[ +Some(aiur_trace_fixtures_0), +Some(aiur_trace_fixtures_1), +Some(aiur_trace_fixtures_2), +Some(aiur_trace_fixtures_3), +Some(aiur_trace_fixtures_4), +Some(aiur_trace_fixtures_5), +Some(aiur_trace_fixtures_6), +Some(aiur_trace_fixtures_7), +Some(aiur_trace_fixtures_8), +Some(aiur_trace_fixtures_9), +Some(aiur_trace_fixtures_10), +Some(aiur_trace_fixtures_11), +Some(aiur_trace_fixtures_12), +None, +Some(aiur_trace_fixtures_14), +Some(aiur_trace_fixtures_15), +Some(aiur_trace_fixtures_16), +Some(aiur_trace_fixtures_17), +Some(aiur_trace_fixtures_18), +Some(aiur_trace_fixtures_19), +Some(aiur_trace_fixtures_20), +Some(aiur_trace_fixtures_21) +], &[3, 3, 13, 3, 6, 2, 3, 7, 3, 3, 6, 15, 1, 0, 3, 2, 1, 162, 5, 2, 13, 17], &[24, 16, 24, 24, 40, 16, 24, 48, 24, 24, 48, 112, 8, 0, 24, 16, 8, 176, 40, 16, 24, 136]) }; diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 43d2876eb..63c5a874a 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -12,1025 +12,1025 @@ use aiur::execute::{ExecError, IOBuffer, QueryRecord}; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; const OUT_0: usize = 1; -fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_4]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = (__v_2 - __v_3); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, (&__args[..]))?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: 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_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_9]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_1(inp: [G; IN_1], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_4]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_1 + __v_3; let __v_5: G = __v_2 - __v_3; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, &__args[..])?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: 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_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_9]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_2: usize = 8; const IN_2: usize = 8; const OUT_2: usize = 1; -fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_3: usize = 8; const IN_3: usize = 8; const OUT_3: usize = 4; -fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __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)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); 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)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; 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_13: G = (__v_12 * __v_12); 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_3] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[3].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __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)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); 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); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; 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_13: G = __v_12 * __v_12; 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_3] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_4: usize = 12; const IN_4: usize = 12; const OUT_4: usize = 4; -fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 & 4294967295)).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_4] = [__v_12, __v_13, __v_14, __v_15]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 & 4294967295).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_4] = [__v_12, __v_13, __v_14, __v_15]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_value(__v_0, __v_4, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[5].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_5(inp: [G; IN_5], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_value(__v_0, __v_4, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[5].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_6: usize = 4; const IN_6: usize = 4; const OUT_6: usize = 4; -fn aiur_fn_6(inp: [G; IN_6], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __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_6] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_6(inp: [G; IN_6], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __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_6] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_7: usize = 4; const IN_7: usize = 4; const OUT_7: usize = 4; -fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __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]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __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]; record.function_queries[7].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_8 + __v_11); 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_8] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[8].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_8(inp: [G; IN_8], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = __v_8 + __v_11; 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_8] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[8].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_9: usize = 8; const IN_9: usize = 8; const OUT_9: usize = 4; -fn aiur_fn_9(inp: [G; IN_9], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split4_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split4_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split4_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split4_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_10 + __v_13); 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_9] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[9].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_9(inp: [G; IN_9], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_split4_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_split4_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_split4_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_split4_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = __v_10 + __v_13; 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_9] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[9].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_10: usize = 16; const IN_10: usize = 16; const OUT_10: usize = 1; -fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = (__v_0 - __v_8); let __v_17: G = (__v_1 - __v_9); let __v_18: G = (__v_2 - __v_10); let __v_19: G = (__v_3 - __v_11); let __v_20: G = (__v_4 - __v_12); let __v_21: G = (__v_5 - __v_13); let __v_22: G = (__v_6 - __v_14); let __v_23: G = (__v_7 - __v_15); match __v_16.as_canonical_u64() { 0u64 => { match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = __v_0 - __v_8; let __v_17: G = __v_1 - __v_9; let __v_18: G = __v_2 - __v_10; let __v_19: G = __v_3 - __v_11; let __v_20: G = __v_4 - __v_12; let __v_21: G = __v_5 - __v_13; let __v_22: G = __v_6 - __v_14; let __v_23: G = __v_7 - __v_15; match __v_16.as_canonical_u64() { 0u64 => { match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_11: usize = 8; const IN_11: usize = 8; const OUT_11: usize = 8; -fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { 255u64 => { match __v_2.as_canonical_u64() { 255u64 => { match __v_3.as_canonical_u64() { 255u64 => { match __v_4.as_canonical_u64() { 255u64 => { match __v_5.as_canonical_u64() { 255u64 => { match __v_6.as_canonical_u64() { 255u64 => { match __v_7.as_canonical_u64() { 255u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_7 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_6 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_11] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { 255u64 => { match __v_2.as_canonical_u64() { 255u64 => { match __v_3.as_canonical_u64() { 255u64 => { match __v_4.as_canonical_u64() { 255u64 => { match __v_5.as_canonical_u64() { 255u64 => { match __v_6.as_canonical_u64() { 255u64 => { match __v_7.as_canonical_u64() { 255u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_7 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_6 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_5 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_4 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_1 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_0 + __v_8; let __ret: [G; OUT_11] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); } let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_1); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_2); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_3); let __v_15: G = G::from_u64(4294967296); let __v_16: G = (__v_15 * __v_4); let __v_17: G = G::from_u64(1099511627776); let __v_18: G = (__v_17 * __v_5); let __v_19: G = G::from_u64(281474976710656); let __v_20: G = (__v_19 * __v_6); let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); let __v_23: G = (__v_14 + __v_22); let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_12] = [__v_26]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); } let __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_1; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_2; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_3; let __v_15: G = G::from_u64(4294967296); let __v_16: G = __v_15 * __v_4; let __v_17: G = G::from_u64(1099511627776); let __v_18: G = __v_17 * __v_5; let __v_19: G = G::from_u64(281474976710656); let __v_20: G = __v_19 * __v_6; let __v_21: G = __v_18 + __v_20; let __v_22: G = __v_16 + __v_21; let __v_23: G = __v_14 + __v_22; let __v_24: G = __v_12 + __v_23; let __v_25: G = __v_10 + __v_24; let __v_26: G = __v_0 + __v_25; let __ret: [G; OUT_12] = [__v_26]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_13: usize = 8; const IN_13: usize = 8; const OUT_13: usize = 1; -fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(256); let __v_9: G = (__v_8 * __v_1); let __v_10: G = G::from_u64(65536); let __v_11: G = (__v_10 * __v_2); let __v_12: G = G::from_u64(16777216); let __v_13: G = (__v_12 * __v_3); let __v_14: G = G::from_u64(4294967296); let __v_15: G = (__v_14 * __v_4); let __v_16: G = G::from_u64(1099511627776); let __v_17: G = (__v_16 * __v_5); let __v_18: G = G::from_u64(281474976710656); let __v_19: G = (__v_18 * __v_6); let __v_20: G = G::from_u64(72057594037927936); let __v_21: G = (__v_20 * __v_7); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_17 + __v_22); let __v_24: G = (__v_15 + __v_23); let __v_25: G = (__v_13 + __v_24); 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_13] = [__v_28]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(256); let __v_9: G = __v_8 * __v_1; let __v_10: G = G::from_u64(65536); let __v_11: G = __v_10 * __v_2; let __v_12: G = G::from_u64(16777216); let __v_13: G = __v_12 * __v_3; let __v_14: G = G::from_u64(4294967296); let __v_15: G = __v_14 * __v_4; let __v_16: G = G::from_u64(1099511627776); let __v_17: G = __v_16 * __v_5; let __v_18: G = G::from_u64(281474976710656); let __v_19: G = __v_18 * __v_6; let __v_20: G = G::from_u64(72057594037927936); let __v_21: G = __v_20 * __v_7; let __v_22: G = __v_19 + __v_21; let __v_23: G = __v_17 + __v_22; let __v_24: G = __v_15 + __v_23; let __v_25: G = __v_13 + __v_24; 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_13] = [__v_28]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_14: usize = 8; const IN_14: usize = 8; const OUT_14: usize = 1; -fn aiur_fn_14(inp: [G; IN_14], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_4 + __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = (__v_2 + __v_3); let __v_15: G = (__v_1 + __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_bool((__v_16 == G::ZERO)); let __v_18: G = G::from_u64(1); let __v_19: G = (__v_18 - __v_17); let __v_20: G = (__v_13 * __v_19); let __v_21: G = (__v_18 - __v_20); let __ret: [G; OUT_14] = [__v_21]; record.function_queries[14].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_14(inp: [G; IN_14], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = __v_7 - __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_5 + __v_10; let __v_12: G = __v_4 + __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_2 + __v_3; let __v_15: G = __v_1 + __v_14; let __v_16: G = __v_0 + __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = G::from_u64(1); let __v_19: G = __v_18 - __v_17; let __v_20: G = __v_13 * __v_19; let __v_21: G = __v_18 - __v_20; let __ret: [G; OUT_14] = [__v_21]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_15: usize = 1; const IN_15: usize = 1; const OUT_15: usize = 8; -fn aiur_fn_15(inp: [G; IN_15], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); let __v_3: G = G::from_u8(__gb[2]); let __v_4: G = G::from_u8(__gb[3]); let __v_5: G = G::from_u8(__gb[4]); let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_1; let __vj = __v_2; 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_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 __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_2); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_3); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_4); let __v_15: G = G::from_u64(4294967296); let __v_16: G = (__v_15 * __v_5); let __v_17: G = G::from_u64(1099511627776); let __v_18: G = (__v_17 * __v_6); let __v_19: G = G::from_u64(281474976710656); let __v_20: G = (__v_19 * __v_7); let __v_21: G = G::from_u64(72057594037927936); let __v_22: G = (__v_21 * __v_8); let __v_23: G = (__v_20 + __v_22); let __v_24: G = (__v_18 + __v_23); let __v_25: G = (__v_16 + __v_24); let __v_26: G = (__v_14 + __v_25); let __v_27: G = (__v_12 + __v_26); let __v_28: G = (__v_10 + __v_27); let __v_29: G = (__v_1 + __v_28); if (__v_29 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_30: G = G::from_u64(1020); let __v_31: G = (__v_8 - __v_30); let __v_32: G = (__v_7 + __v_31); let __v_33: G = (__v_6 + __v_32); let __v_34: G = (__v_5 + __v_33); let __v_35: G = G::from_bool((__v_34 == G::ZERO)); let __v_36: G = (__v_3 + __v_4); let __v_37: G = (__v_2 + __v_36); let __v_38: G = (__v_1 + __v_37); let __v_39: G = G::from_bool((__v_38 == G::ZERO)); let __v_40: G = G::from_u64(1); let __v_41: G = (__v_40 - __v_39); let __v_42: G = (__v_35 * __v_41); let __v_43: G = (__v_40 - __v_42); if (__v_43 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_15(inp: [G; IN_15], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); let __v_3: G = G::from_u8(__gb[2]); let __v_4: G = G::from_u8(__gb[3]); let __v_5: G = G::from_u8(__gb[4]); let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_1; let __vj = __v_2; 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_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 __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_2; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_3; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_4; let __v_15: G = G::from_u64(4294967296); let __v_16: G = __v_15 * __v_5; let __v_17: G = G::from_u64(1099511627776); let __v_18: G = __v_17 * __v_6; let __v_19: G = G::from_u64(281474976710656); let __v_20: G = __v_19 * __v_7; let __v_21: G = G::from_u64(72057594037927936); let __v_22: G = __v_21 * __v_8; let __v_23: G = __v_20 + __v_22; let __v_24: G = __v_18 + __v_23; let __v_25: G = __v_16 + __v_24; let __v_26: G = __v_14 + __v_25; let __v_27: G = __v_12 + __v_26; let __v_28: G = __v_10 + __v_27; let __v_29: G = __v_1 + __v_28; if (__v_29 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_30: G = G::from_u64(1020); let __v_31: G = __v_8 - __v_30; let __v_32: G = __v_7 + __v_31; let __v_33: G = __v_6 + __v_32; let __v_34: G = __v_5 + __v_33; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = __v_3 + __v_4; let __v_37: G = __v_2 + __v_36; let __v_38: G = __v_1 + __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = G::from_u64(1); let __v_41: G = __v_40 - __v_39; let __v_42: G = __v_35 * __v_41; let __v_43: G = __v_40 - __v_42; if (__v_43 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[15].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_16: usize = 1; const IN_16: usize = 1; const OUT_16: usize = 1; -fn aiur_fn_16(inp: [G; IN_16], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = aiur::execute::g_inverse_value(__v_0); let __v_2: G = (__v_0 * __v_1); let __v_3: G = G::from_u64(1); let __v_4: G = (__v_2 - __v_3); let __v_5: G = (__v_0 * __v_4); let __v_6: G = G::from_u64(0); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_7: G = (__v_1 * __v_4); if (__v_7 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_16] = [__v_1]; record.function_queries[16].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_16(inp: [G; IN_16], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = aiur::execute::g_inverse_value(__v_0); let __v_2: G = __v_0 * __v_1; let __v_3: G = G::from_u64(1); let __v_4: G = __v_2 - __v_3; let __v_5: G = __v_0 * __v_4; let __v_6: G = G::from_u64(0); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_7: G = __v_1 * __v_4; if (__v_7 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_16] = [__v_1]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_17: usize = 4; const IN_17: usize = 4; const OUT_17: usize = 2; -fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 + __v_2); let __v_5: G = (__v_1 + __v_3); let __ret: [G; OUT_17] = [__v_4, __v_5]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 + __v_2; let __v_5: G = __v_1 + __v_3; let __ret: [G; OUT_17] = [__v_4, __v_5]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = (__v_1 - __v_3); let __ret: [G; OUT_18] = [__v_4, __v_5]; record.function_queries[18].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_18(inp: [G; IN_18], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 - __v_2; let __v_5: G = __v_1 - __v_3; let __ret: [G; OUT_18] = [__v_4, __v_5]; record.function_queries[18].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __v_3: G = (__v_2 - __v_0); let __v_4: G = (__v_2 - __v_1); let __ret: [G; OUT_19] = [__v_3, __v_4]; record.function_queries[19].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_19(inp: [G; IN_19], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __v_3: G = __v_2 - __v_0; let __v_4: G = __v_2 - __v_1; let __ret: [G; OUT_19] = [__v_3, __v_4]; record.function_queries[19].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_1 * __v_3); let __v_7: G = (__v_5 * __v_6); let __v_8: G = (__v_4 + __v_7); 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_20] = [__v_8, __v_11]; record.function_queries[20].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_20(inp: [G; IN_20], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 * __v_2; let __v_5: G = G::from_u64(7); let __v_6: G = __v_1 * __v_3; let __v_7: G = __v_5 * __v_6; let __v_8: G = __v_4 + __v_7; 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_20] = [__v_8, __v_11]; record.function_queries[20].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_21: usize = 2; const IN_21: usize = 2; const OUT_21: usize = 2; -fn aiur_fn_21(inp: [G; IN_21], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 * __v_0); let __v_3: G = G::from_u64(7); let __v_4: G = (__v_1 * __v_1); let __v_5: G = (__v_3 * __v_4); let __v_6: G = (__v_2 - __v_5); let __v_7: G = aiur::execute::g_inverse_value(__v_6); let __v_8: G = (__v_6 * __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 - __v_9); let __v_11: G = (__v_6 * __v_10); 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: None }); } let __v_13: G = (__v_7 * __v_10); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_14: G = (__v_0 * __v_7); let __v_15: G = (__v_12 - __v_1); let __v_16: G = (__v_15 * __v_7); let __ret: [G; OUT_21] = [__v_14, __v_16]; record.function_queries[21].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_21(inp: [G; IN_21], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = __v_0 * __v_0; let __v_3: G = G::from_u64(7); let __v_4: G = __v_1 * __v_1; let __v_5: G = __v_3 * __v_4; let __v_6: G = __v_2 - __v_5; let __v_7: G = aiur::execute::g_inverse_value(__v_6); let __v_8: G = __v_6 * __v_7; let __v_9: G = G::from_u64(1); let __v_10: G = __v_8 - __v_9; let __v_11: G = __v_6 * __v_10; 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: None }); } let __v_13: G = __v_7 * __v_10; if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_14: G = __v_0 * __v_7; let __v_15: G = __v_12 - __v_1; let __v_16: G = __v_15 * __v_7; let __ret: [G; OUT_21] = [__v_14, __v_16]; record.function_queries[21].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_22: usize = 4; const IN_22: usize = 4; const OUT_22: usize = 2; -fn aiur_fn_22(inp: [G; IN_22], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_2 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_3 * __v_3); let __v_7: G = (__v_5 * __v_6); let __v_8: G = (__v_4 - __v_7); let __v_9: G = aiur::execute::g_inverse_value(__v_8); let __v_10: G = (__v_8 * __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 - __v_11); let __v_13: G = (__v_8 * __v_12); let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_9 * __v_12); if (__v_15 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_16: G = (__v_2 * __v_9); let __v_17: G = (__v_14 - __v_3); let __v_18: G = (__v_17 * __v_9); let __v_19: G = (__v_0 * __v_16); let __v_20: G = (__v_1 * __v_18); let __v_21: G = (__v_5 * __v_20); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_0 * __v_18); let __v_24: G = (__v_1 * __v_16); let __v_25: G = (__v_23 + __v_24); let __ret: [G; OUT_22] = [__v_22, __v_25]; record.function_queries[22].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_22(inp: [G; IN_22], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_2 * __v_2; let __v_5: G = G::from_u64(7); let __v_6: G = __v_3 * __v_3; let __v_7: G = __v_5 * __v_6; let __v_8: G = __v_4 - __v_7; let __v_9: G = aiur::execute::g_inverse_value(__v_8); let __v_10: G = __v_8 * __v_9; let __v_11: G = G::from_u64(1); let __v_12: G = __v_10 - __v_11; let __v_13: G = __v_8 * __v_12; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = __v_9 * __v_12; if (__v_15 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_16: G = __v_2 * __v_9; let __v_17: G = __v_14 - __v_3; let __v_18: G = __v_17 * __v_9; let __v_19: G = __v_0 * __v_16; let __v_20: G = __v_1 * __v_18; let __v_21: G = __v_5 * __v_20; let __v_22: G = __v_19 + __v_21; let __v_23: G = __v_0 * __v_18; let __v_24: G = __v_1 * __v_16; let __v_25: G = __v_23 + __v_24; let __ret: [G; OUT_22] = [__v_22, __v_25]; record.function_queries[22].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_23: usize = 4; const IN_23: usize = 4; const OUT_23: usize = 1; -fn aiur_fn_23(inp: [G; IN_23], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); 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_23] = [__v_8]; record.function_queries[23].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_23(inp: [G; IN_23], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 - __v_2; let __v_5: G = G::from_bool(__v_4 == G::ZERO); 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_23] = [__v_8]; record.function_queries[23].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_24] = [__v_2, __v_3]; record.function_queries[24].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_24] = [__v_4, __v_6]; record.function_queries[24].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_24(inp: [G; IN_24], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_24] = [__v_2, __v_3]; record.function_queries[24].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_24] = [__v_4, __v_6]; record.function_queries[24].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_25: usize = 1; const IN_25: usize = 1; const OUT_25: usize = 9; -fn aiur_fn_25(inp: [G; IN_25], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_25] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[25].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_25(inp: [G; IN_25], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_25] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[25].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_26: usize = 1; const IN_26: usize = 1; const OUT_26: usize = 2; -fn aiur_fn_26(inp: [G; IN_26], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, (&__args[..]))?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { (*(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25])) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; 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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_10, __v_9]; record.function_queries[26].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_26(inp: [G; IN_26], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, &__args[..])?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; 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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_10, __v_9]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; 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_27] = [__v_2, __v_4]; record.function_queries[27].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_27(inp: [G; IN_27], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; 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_27] = [__v_2, __v_4]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_28: usize = 1; const IN_28: usize = 1; const OUT_28: usize = 9; -fn aiur_fn_28(inp: [G; IN_28], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = __io_read[1]; let __v_4: G = __io_read[2]; let __v_5: G = __io_read[3]; let __v_6: G = __io_read[4]; let __v_7: G = __io_read[5]; let __v_8: G = __io_read[6]; 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_28] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[28].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_28(inp: [G; IN_28], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = __io_read[1]; let __v_4: G = __io_read[2]; let __v_5: G = __io_read[3]; let __v_6: G = __io_read[4]; let __v_7: G = __io_read[5]; let __v_8: G = __io_read[6]; 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_28] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[28].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_29: usize = 1; const IN_29: usize = 1; const OUT_29: usize = 2; -fn aiur_fn_29(inp: [G; IN_29], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_10, __v_9]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_29(inp: [G; IN_29], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_10, __v_9]; record.function_queries[29].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_30: usize = 1; const IN_30: usize = 1; const OUT_30: usize = 3; -fn aiur_fn_30(inp: [G; IN_30], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = G::from_u64(256); let __v_20: G = (__v_19 * __v_2); let __v_21: G = G::from_u64(65536); let __v_22: G = (__v_21 * __v_3); let __v_23: G = G::from_u64(16777216); let __v_24: G = (__v_23 * __v_4); let __v_25: G = G::from_u64(4294967296); let __v_26: G = (__v_25 * __v_5); let __v_27: G = G::from_u64(1099511627776); let __v_28: G = (__v_27 * __v_6); let __v_29: G = G::from_u64(281474976710656); let __v_30: G = (__v_29 * __v_7); let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = (__v_31 * __v_8); let __v_33: G = (__v_30 + __v_32); let __v_34: G = (__v_28 + __v_33); let __v_35: G = (__v_26 + __v_34); let __v_36: G = (__v_24 + __v_35); let __v_37: G = (__v_22 + __v_36); let __v_38: G = (__v_20 + __v_37); let __v_39: G = (__v_1 + __v_38); let __v_40: G = (__v_19 * __v_11); let __v_41: G = (__v_21 * __v_12); let __v_42: G = (__v_23 * __v_13); let __v_43: G = (__v_25 * __v_14); let __v_44: G = (__v_27 * __v_15); let __v_45: G = (__v_29 * __v_16); let __v_46: G = (__v_31 * __v_17); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_44 + __v_47); let __v_49: G = (__v_43 + __v_48); let __v_50: G = (__v_42 + __v_49); let __v_51: G = (__v_41 + __v_50); let __v_52: G = (__v_40 + __v_51); let __v_53: G = (__v_10 + __v_52); let __ret: [G; OUT_30] = [__v_39, __v_53, __v_18]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_30(inp: [G; IN_30], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = G::from_u64(256); let __v_20: G = __v_19 * __v_2; let __v_21: G = G::from_u64(65536); let __v_22: G = __v_21 * __v_3; let __v_23: G = G::from_u64(16777216); let __v_24: G = __v_23 * __v_4; let __v_25: G = G::from_u64(4294967296); let __v_26: G = __v_25 * __v_5; let __v_27: G = G::from_u64(1099511627776); let __v_28: G = __v_27 * __v_6; let __v_29: G = G::from_u64(281474976710656); let __v_30: G = __v_29 * __v_7; let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = __v_31 * __v_8; let __v_33: G = __v_30 + __v_32; let __v_34: G = __v_28 + __v_33; let __v_35: G = __v_26 + __v_34; let __v_36: G = __v_24 + __v_35; let __v_37: G = __v_22 + __v_36; let __v_38: G = __v_20 + __v_37; let __v_39: G = __v_1 + __v_38; let __v_40: G = __v_19 * __v_11; let __v_41: G = __v_21 * __v_12; let __v_42: G = __v_23 * __v_13; let __v_43: G = __v_25 * __v_14; let __v_44: G = __v_27 * __v_15; let __v_45: G = __v_29 * __v_16; let __v_46: G = __v_31 * __v_17; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_44 + __v_47; let __v_49: G = __v_43 + __v_48; let __v_50: G = __v_42 + __v_49; let __v_51: G = __v_41 + __v_50; let __v_52: G = __v_40 + __v_51; let __v_53: G = __v_10 + __v_52; let __ret: [G; OUT_30] = [__v_39, __v_53, __v_18]; record.function_queries[30].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_31: usize = 1; const IN_31: usize = 1; const OUT_31: usize = 33; -fn aiur_fn_31(inp: [G; IN_31], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_27]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_31] = [__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]; record.function_queries[31].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_31(inp: [G; IN_31], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_27]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_31] = [__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]; record.function_queries[31].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_32] = [__v_3, __v_4]; record.function_queries[32].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_32(inp: [G; IN_32], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_32] = [__v_3, __v_4]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_3, __v_0]; record.function_queries[33].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; 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_33] = { let __args: [G; IN_33] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_9, __v_7]; record.function_queries[33].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_33(inp: [G; IN_33], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_3, __v_0]; record.function_queries[33].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; 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_33] = { let __args: [G; IN_33] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_9, __v_7]; record.function_queries[33].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_34(inp: [G; IN_34], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_3, __v_0]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_16, __v_14]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_35(inp: [G; IN_35], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_3, __v_0]; record.function_queries[35].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_16, __v_14]; record.function_queries[35].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(37, (&__args[..]))?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { (*(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37])) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_36(inp: [G; IN_36], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(37, &__args[..])?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_3, __v_0]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = G::from_u64(256); let __v_21: G = (__v_20 * __v_3); let __v_22: G = G::from_u64(65536); let __v_23: G = (__v_22 * __v_4); let __v_24: G = G::from_u64(16777216); let __v_25: G = (__v_24 * __v_5); let __v_26: G = G::from_u64(4294967296); let __v_27: G = (__v_26 * __v_6); let __v_28: G = G::from_u64(1099511627776); let __v_29: G = (__v_28 * __v_7); let __v_30: G = G::from_u64(281474976710656); let __v_31: G = (__v_30 * __v_8); let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = (__v_32 * __v_9); let __v_34: G = (__v_31 + __v_33); let __v_35: G = (__v_29 + __v_34); let __v_36: G = (__v_27 + __v_35); let __v_37: G = (__v_25 + __v_36); let __v_38: G = (__v_23 + __v_37); let __v_39: G = (__v_21 + __v_38); let __v_40: G = (__v_2 + __v_39); let __v_41: G = (__v_20 * __v_12); let __v_42: G = (__v_22 * __v_13); let __v_43: G = (__v_24 * __v_14); let __v_44: G = (__v_26 * __v_15); let __v_45: G = (__v_28 * __v_16); let __v_46: G = (__v_30 * __v_17); let __v_47: G = (__v_32 * __v_18); let __v_48: G = (__v_46 + __v_47); let __v_49: G = (__v_45 + __v_48); let __v_50: G = (__v_44 + __v_49); let __v_51: G = (__v_43 + __v_50); let __v_52: G = (__v_42 + __v_51); let __v_53: G = (__v_41 + __v_52); let __v_54: G = (__v_11 + __v_53); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_1 - __v_55); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, (&__args[..]))?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { (*(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37])) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = G::from_u64(0); let __v_60: G = { let __values: [G; 4] = [__v_59, __v_40, __v_54, __v_57]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_60, __v_58]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_37(inp: [G; IN_37], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_3, __v_0]; record.function_queries[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = G::from_u64(256); let __v_21: G = __v_20 * __v_3; let __v_22: G = G::from_u64(65536); let __v_23: G = __v_22 * __v_4; let __v_24: G = G::from_u64(16777216); let __v_25: G = __v_24 * __v_5; let __v_26: G = G::from_u64(4294967296); let __v_27: G = __v_26 * __v_6; let __v_28: G = G::from_u64(1099511627776); let __v_29: G = __v_28 * __v_7; let __v_30: G = G::from_u64(281474976710656); let __v_31: G = __v_30 * __v_8; let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = __v_32 * __v_9; let __v_34: G = __v_31 + __v_33; let __v_35: G = __v_29 + __v_34; let __v_36: G = __v_27 + __v_35; let __v_37: G = __v_25 + __v_36; let __v_38: G = __v_23 + __v_37; let __v_39: G = __v_21 + __v_38; let __v_40: G = __v_2 + __v_39; let __v_41: G = __v_20 * __v_12; let __v_42: G = __v_22 * __v_13; let __v_43: G = __v_24 * __v_14; let __v_44: G = __v_26 * __v_15; let __v_45: G = __v_28 * __v_16; let __v_46: G = __v_30 * __v_17; let __v_47: G = __v_32 * __v_18; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_45 + __v_48; let __v_50: G = __v_44 + __v_49; let __v_51: G = __v_43 + __v_50; let __v_52: G = __v_42 + __v_51; let __v_53: G = __v_41 + __v_52; let __v_54: G = __v_11 + __v_53; let __v_55: G = G::from_u64(1); let __v_56: G = __v_1 - __v_55; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, &__args[..])?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = G::from_u64(0); let __v_60: G = { let __values: [G; 4] = [__v_59, __v_40, __v_54, __v_57]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_60, __v_58]; record.function_queries[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(39, (&__args[..]))?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { (*(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39])) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_38(inp: [G; IN_38], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(39, &__args[..])?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_3, __v_0]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, (&__args[..]))?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { (*(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39])) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_44, __v_41]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_39(inp: [G; IN_39], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_3, __v_0]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_38: G = G::from_u64(1); let __v_39: G = __v_1 - __v_38; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, &__args[..])?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_44, __v_41]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_40(inp: [G; IN_40], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_3, __v_0]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_9, __v_7]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_41(inp: [G; IN_41], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_3, __v_0]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_9, __v_7]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_42(inp: [G; IN_42], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_3, __v_0]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; 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_43] = { let __args: [G; IN_43] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_11, __v_9]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_43(inp: [G; IN_43], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_3, __v_0]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; 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_43] = { let __args: [G; IN_43] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_11, __v_9]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_44(inp: [G; IN_44], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_45: usize = 2; const IN_45: usize = 2; const OUT_45: usize = 2; -fn aiur_fn_45(inp: [G; IN_45], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_3, __v_0]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; 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_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_9, __v_7]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_45(inp: [G; IN_45], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_3, __v_0]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; 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_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_9, __v_7]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_46: usize = 1; const IN_46: usize = 1; const OUT_46: usize = 2; -fn aiur_fn_46(inp: [G; IN_46], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_3, __v_4]; record.function_queries[46].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_46(inp: [G; IN_46], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_3, __v_4]; record.function_queries[46].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_47: usize = 2; const IN_47: usize = 2; const OUT_47: usize = 2; -fn aiur_fn_47(inp: [G; IN_47], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_3, __v_0]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(44, (&__args[..]))?) { [G::ZERO; OUT_44] } else { let (__hash, __hit) = record.function_queries[44].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[44].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { (*(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44])) }; __ret }, _ => { aiur_fn_44::(__args, __hash, record, io_buffer)? }, } } }; 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_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_9, __v_7]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_47(inp: [G; IN_47], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_3, __v_0]; record.function_queries[47].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(44, &__args[..])?) { [G::ZERO; OUT_44] } else { let (__hash, __hit) = record.function_queries[44].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[44].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => { aiur_fn_44::(__args, __hash, record, io_buffer)? }, } } }; 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_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_9, __v_7]; record.function_queries[47].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_48: usize = 1; const IN_48: usize = 1; const OUT_48: usize = 2; -fn aiur_fn_48(inp: [G; IN_48], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_48] = [__v_1, __v_2]; record.function_queries[48].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_48(inp: [G; IN_48], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_48] = [__v_1, __v_2]; record.function_queries[48].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_49: usize = 1; const IN_49: usize = 1; const OUT_49: usize = 2; -fn aiur_fn_49(inp: [G; IN_49], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_3, __v_4]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_49(inp: [G; IN_49], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_3, __v_4]; record.function_queries[49].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_3, __v_0]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; 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_50] = { let __args: [G; IN_50] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_9, __v_7]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_50(inp: [G; IN_50], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_3, __v_0]; record.function_queries[50].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; 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_50] = { let __args: [G; IN_50] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_9, __v_7]; record.function_queries[50].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_51: usize = 1; const IN_51: usize = 1; const OUT_51: usize = 4; -fn aiur_fn_51(inp: [G; IN_51], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; 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]; record.function_queries[51].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_51(inp: [G; IN_51], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; 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]; record.function_queries[51].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_52: usize = 1; const IN_52: usize = 1; const OUT_52: usize = 3; -fn aiur_fn_52(inp: [G; IN_52], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_52] = [__v_3, __v_5, __v_6]; record.function_queries[52].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_52(inp: [G; IN_52], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_52] = [__v_3, __v_5, __v_6]; record.function_queries[52].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_53: usize = 1; const IN_53: usize = 1; const OUT_53: usize = 2; -fn aiur_fn_53(inp: [G; IN_53], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_3, __v_4]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_53(inp: [G; IN_53], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_3, __v_4]; record.function_queries[53].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_54: usize = 2; const IN_54: usize = 2; const OUT_54: usize = 2; -fn aiur_fn_54(inp: [G; IN_54], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_3, __v_0]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; 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_54] = { let __args: [G; IN_54] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_13, __v_11]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_54(inp: [G; IN_54], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_3, __v_0]; record.function_queries[54].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; 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_54] = { let __args: [G; IN_54] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_13, __v_11]; record.function_queries[54].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_55: usize = 1; const IN_55: usize = 1; const OUT_55: usize = 4; -fn aiur_fn_55(inp: [G; IN_55], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_55] = [__v_1, __v_5, __v_7, __v_8]; record.function_queries[55].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_55(inp: [G; IN_55], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_55] = [__v_1, __v_5, __v_7, __v_8]; record.function_queries[55].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_56: usize = 1; const IN_56: usize = 1; const OUT_56: usize = 2; -fn aiur_fn_56(inp: [G; IN_56], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_3, __v_4]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_56(inp: [G; IN_56], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_3, __v_4]; record.function_queries[56].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_57: usize = 2; const IN_57: usize = 2; const OUT_57: usize = 2; -fn aiur_fn_57(inp: [G; IN_57], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 5] = [__v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 5)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_3, __v_0]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; 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; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 5)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_15, __v_13]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_57(inp: [G; IN_57], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 5] = [__v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 5)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_3, __v_0]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = __v_1 - __v_10; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; 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; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 5)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_15, __v_13]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_58: usize = 1; const IN_58: usize = 1; const OUT_58: usize = 14; -fn aiur_fn_58(inp: [G; IN_58], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_16]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_58] = [__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]; record.function_queries[58].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_58(inp: [G; IN_58], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_16]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_58] = [__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]; record.function_queries[58].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_59: usize = 1; const IN_59: usize = 1; const OUT_59: usize = 3; -fn aiur_fn_59(inp: [G; IN_59], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_59] = [__v_3, __v_3, __v_2]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_59] = [__v_5, __v_3, __v_4]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_59(inp: [G; IN_59], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_59] = [__v_3, __v_3, __v_2]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_59] = [__v_5, __v_3, __v_4]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_60: usize = 1; const IN_60: usize = 1; const OUT_60: usize = 25; -fn aiur_fn_60(inp: [G; IN_60], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_14, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_28, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_32]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_46] = { let __args: [G; IN_46] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, (&__args[..]))?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { (*(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59])) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; 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_46] = { let __args: [G; IN_46] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_60] = [__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]; record.function_queries[60].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_60(inp: [G; IN_60], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_14, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_28, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_32]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; 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_46] = { let __args: [G; IN_46] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, &__args[..])?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; 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_46] = { let __args: [G; IN_46] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_60] = [__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]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_61: usize = 1; const IN_61: usize = 1; const OUT_61: usize = 5; -fn aiur_fn_61(inp: [G; IN_61], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_3, __v_5, __v_9, __v_13, __v_14]; record.function_queries[61].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_61(inp: [G; IN_61], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; 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 ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_3, __v_5, __v_9, __v_13, __v_14]; record.function_queries[61].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_62: usize = 1; const IN_62: usize = 1; const OUT_62: usize = 2; -fn aiur_fn_62(inp: [G; IN_62], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_62] = [__v_3, __v_4]; record.function_queries[62].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_62(inp: [G; IN_62], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_62] = [__v_3, __v_4]; record.function_queries[62].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_63: usize = 2; const IN_63: usize = 2; const OUT_63: usize = 2; -fn aiur_fn_63(inp: [G; IN_63], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_3, __v_0]; record.function_queries[63].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_9, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_13, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_1 - __v_16); let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 6] = [__v_20, __v_4, __v_6, __v_10, __v_14, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_21, __v_19]; record.function_queries[63].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_63(inp: [G; IN_63], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_3, __v_0]; record.function_queries[63].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_9, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_13, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(1); let __v_17: G = __v_1 - __v_16; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 6] = [__v_20, __v_4, __v_6, __v_10, __v_14, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_21, __v_19]; record.function_queries[63].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_64: usize = 1; const IN_64: usize = 1; const OUT_64: usize = 10; -fn aiur_fn_64(inp: [G; IN_64], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_2]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __ret: [G; OUT_64] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[64].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_64(inp: [G; IN_64], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_2]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __ret: [G; OUT_64] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_65: usize = 1; const IN_65: usize = 1; const OUT_65: usize = 2; -fn aiur_fn_65(inp: [G; IN_65], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_65] = [__v_3, __v_4]; record.function_queries[65].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_65(inp: [G; IN_65], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_65] = [__v_3, __v_4]; record.function_queries[65].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_66: usize = 2; const IN_66: usize = 2; const OUT_66: usize = 2; -fn aiur_fn_66(inp: [G; IN_66], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_3, __v_0]; record.function_queries[66].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_3]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 11] = [__v_17, __v_2, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_15]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_18, __v_16]; record.function_queries[66].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_66(inp: [G; IN_66], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_3, __v_0]; record.function_queries[66].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_3]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __v_13: G = G::from_u64(1); let __v_14: G = __v_1 - __v_13; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 11] = [__v_17, __v_2, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_15]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_18, __v_16]; record.function_queries[66].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_67: usize = 1; const IN_67: usize = 1; const OUT_67: usize = 2; -fn aiur_fn_67(inp: [G; IN_67], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_67] = [__v_3, __v_4]; record.function_queries[67].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_67(inp: [G; IN_67], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_67] = [__v_3, __v_4]; record.function_queries[67].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_68: usize = 2; const IN_68: usize = 2; const OUT_68: usize = 2; -fn aiur_fn_68(inp: [G; IN_68], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 26] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 26)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_3, __v_0]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(60, (&__args[..]))?) { [G::ZERO; OUT_60] } else { let (__hash, __hit) = record.function_queries[60].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[60].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { (*(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60])) }; __ret }, _ => { aiur_fn_60::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = G::from_u64(1); let __v_28: G = (__v_1 - __v_27); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; 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; 26] = [__v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 26)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_32, __v_30]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_68(inp: [G; IN_68], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 26] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 26)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_3, __v_0]; record.function_queries[68].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(60, &__args[..])?) { [G::ZERO; OUT_60] } else { let (__hash, __hit) = record.function_queries[60].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[60].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => { aiur_fn_60::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = G::from_u64(1); let __v_28: G = __v_1 - __v_27; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; 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; 26] = [__v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 26)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_32, __v_30]; record.function_queries[68].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_69: usize = 1; const IN_69: usize = 1; const OUT_69: usize = 4; -fn aiur_fn_69(inp: [G; IN_69], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_69] = [__v_3, __v_7, __v_11, __v_12]; record.function_queries[69].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_69(inp: [G; IN_69], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_69] = [__v_3, __v_7, __v_11, __v_12]; record.function_queries[69].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_70: usize = 4; const IN_70: usize = 4; const OUT_70: usize = 1; -fn aiur_fn_70(inp: [G; IN_70], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = G::from_u64(65536); let __v_7: G = (__v_6 * __v_2); let __v_8: G = G::from_u64(16777216); let __v_9: G = (__v_8 * __v_3); 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_70] = [__v_12]; record.function_queries[70].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_70(inp: [G; IN_70], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(256); let __v_5: G = __v_4 * __v_1; let __v_6: G = G::from_u64(65536); let __v_7: G = __v_6 * __v_2; let __v_8: G = G::from_u64(16777216); let __v_9: G = __v_8 * __v_3; 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_70] = [__v_12]; record.function_queries[70].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_71: usize = 32; const IN_71: usize = 32; const OUT_71: usize = 8; -fn aiur_fn_71(inp: [G; IN_71], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = G::from_u64(256); let __v_33: G = (__v_32 * __v_1); let __v_34: G = G::from_u64(65536); let __v_35: G = (__v_34 * __v_2); let __v_36: G = G::from_u64(16777216); let __v_37: G = (__v_36 * __v_3); let __v_38: G = (__v_35 + __v_37); let __v_39: G = (__v_33 + __v_38); let __v_40: G = (__v_0 + __v_39); let __v_41: G = (__v_32 * __v_5); let __v_42: G = (__v_34 * __v_6); let __v_43: G = (__v_36 * __v_7); let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_41 + __v_44); let __v_46: G = (__v_4 + __v_45); let __v_47: G = (__v_32 * __v_9); let __v_48: G = (__v_34 * __v_10); let __v_49: G = (__v_36 * __v_11); let __v_50: G = (__v_48 + __v_49); let __v_51: G = (__v_47 + __v_50); let __v_52: G = (__v_8 + __v_51); let __v_53: G = (__v_32 * __v_13); let __v_54: G = (__v_34 * __v_14); let __v_55: G = (__v_36 * __v_15); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_53 + __v_56); let __v_58: G = (__v_12 + __v_57); let __v_59: G = (__v_32 * __v_17); let __v_60: G = (__v_34 * __v_18); let __v_61: G = (__v_36 * __v_19); let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 + __v_62); let __v_64: G = (__v_16 + __v_63); let __v_65: G = (__v_32 * __v_21); let __v_66: G = (__v_34 * __v_22); let __v_67: G = (__v_36 * __v_23); let __v_68: G = (__v_66 + __v_67); let __v_69: G = (__v_65 + __v_68); let __v_70: G = (__v_20 + __v_69); let __v_71: G = (__v_32 * __v_25); let __v_72: G = (__v_34 * __v_26); let __v_73: G = (__v_36 * __v_27); let __v_74: G = (__v_72 + __v_73); let __v_75: G = (__v_71 + __v_74); let __v_76: G = (__v_24 + __v_75); let __v_77: G = (__v_32 * __v_29); let __v_78: G = (__v_34 * __v_30); let __v_79: G = (__v_36 * __v_31); let __v_80: G = (__v_78 + __v_79); let __v_81: G = (__v_77 + __v_80); let __v_82: G = (__v_28 + __v_81); let __ret: [G; OUT_71] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[71].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_71(inp: [G; IN_71], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = G::from_u64(256); let __v_33: G = __v_32 * __v_1; let __v_34: G = G::from_u64(65536); let __v_35: G = __v_34 * __v_2; let __v_36: G = G::from_u64(16777216); let __v_37: G = __v_36 * __v_3; let __v_38: G = __v_35 + __v_37; let __v_39: G = __v_33 + __v_38; let __v_40: G = __v_0 + __v_39; let __v_41: G = __v_32 * __v_5; let __v_42: G = __v_34 * __v_6; let __v_43: G = __v_36 * __v_7; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_41 + __v_44; let __v_46: G = __v_4 + __v_45; let __v_47: G = __v_32 * __v_9; let __v_48: G = __v_34 * __v_10; let __v_49: G = __v_36 * __v_11; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_47 + __v_50; let __v_52: G = __v_8 + __v_51; let __v_53: G = __v_32 * __v_13; let __v_54: G = __v_34 * __v_14; let __v_55: G = __v_36 * __v_15; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_53 + __v_56; let __v_58: G = __v_12 + __v_57; let __v_59: G = __v_32 * __v_17; let __v_60: G = __v_34 * __v_18; let __v_61: G = __v_36 * __v_19; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_59 + __v_62; let __v_64: G = __v_16 + __v_63; let __v_65: G = __v_32 * __v_21; let __v_66: G = __v_34 * __v_22; let __v_67: G = __v_36 * __v_23; let __v_68: G = __v_66 + __v_67; let __v_69: G = __v_65 + __v_68; let __v_70: G = __v_20 + __v_69; let __v_71: G = __v_32 * __v_25; let __v_72: G = __v_34 * __v_26; let __v_73: G = __v_36 * __v_27; let __v_74: G = __v_72 + __v_73; let __v_75: G = __v_71 + __v_74; let __v_76: G = __v_24 + __v_75; let __v_77: G = __v_32 * __v_29; let __v_78: G = __v_34 * __v_30; let __v_79: G = __v_36 * __v_31; let __v_80: G = __v_78 + __v_79; let __v_81: G = __v_77 + __v_80; let __v_82: G = __v_28 + __v_81; let __ret: [G; OUT_71] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[71].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_72: usize = 1; const IN_72: usize = 1; const OUT_72: usize = 32; -fn aiur_fn_72(inp: [G; IN_72], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__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_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]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_72] = [__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]; record.function_queries[72].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_72(inp: [G; IN_72], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__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_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]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_72] = [__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]; record.function_queries[72].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_73: usize = 34; const IN_73: usize = 34; const OUT_73: usize = 34; -fn aiur_fn_73(inp: [G; IN_73], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __loaded[32]; let __v_67: G = __loaded[33]; match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_73] = [__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]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__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 ((!unconstrained) && record.defer_call(73, (&__args[..]))?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { (*(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73])) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; let __v_72: G = __r_arr[3]; let __v_73: G = __r_arr[4]; let __v_74: G = __r_arr[5]; let __v_75: G = __r_arr[6]; let __v_76: G = __r_arr[7]; let __v_77: G = __r_arr[8]; let __v_78: G = __r_arr[9]; let __v_79: G = __r_arr[10]; let __v_80: G = __r_arr[11]; let __v_81: G = __r_arr[12]; let __v_82: G = __r_arr[13]; let __v_83: G = __r_arr[14]; let __v_84: G = __r_arr[15]; let __v_85: G = __r_arr[16]; let __v_86: G = __r_arr[17]; let __v_87: G = __r_arr[18]; let __v_88: G = __r_arr[19]; let __v_89: G = __r_arr[20]; let __v_90: G = __r_arr[21]; let __v_91: G = __r_arr[22]; let __v_92: G = __r_arr[23]; let __v_93: G = __r_arr[24]; let __v_94: G = __r_arr[25]; let __v_95: G = __r_arr[26]; let __v_96: G = __r_arr[27]; let __v_97: G = __r_arr[28]; let __v_98: G = __r_arr[29]; let __v_99: G = __r_arr[30]; let __v_100: G = __r_arr[31]; let __v_101: G = __r_arr[32]; let __v_102: G = __r_arr[33]; match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_73] = [__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]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_103: G = G::from_u64(4); let __v_104: G = G::from_u64(8); let __v_105: G = G::from_u64(103); let __v_106: G = G::from_u64(230); let __v_107: G = G::from_u64(9); let __v_108: G = G::from_u64(106); let __v_109: G = G::from_u64(133); let __v_110: G = G::from_u64(174); let __v_111: G = G::from_u64(187); let __v_112: G = G::from_u64(114); let __v_113: G = G::from_u64(243); let __v_114: G = G::from_u64(110); let __v_115: G = G::from_u64(60); let __v_116: G = G::from_u64(58); let __v_117: G = G::from_u64(245); let __v_118: G = G::from_u64(79); let __v_119: G = G::from_u64(165); let __v_120: G = G::from_u64(127); let __v_121: G = G::from_u64(82); let __v_122: G = G::from_u64(14); let __v_123: G = G::from_u64(81); let __v_124: G = G::from_u64(140); let __v_125: G = G::from_u64(104); let __v_126: G = G::from_u64(5); let __v_127: G = G::from_u64(155); let __v_128: G = G::from_u64(171); let __v_129: G = G::from_u64(217); let __v_130: G = G::from_u64(131); let __v_131: G = G::from_u64(31); let __v_132: G = G::from_u64(25); let __v_133: G = G::from_u64(205); let __v_134: G = G::from_u64(224); let __v_135: G = G::from_u64(91); let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; let __v_139: G = __loaded[3]; let __v_140: G = __loaded[4]; let __v_141: G = __loaded[5]; let __v_142: G = __loaded[6]; let __v_143: G = __loaded[7]; let __v_144: G = __loaded[8]; let __v_145: G = __loaded[9]; let __v_146: G = __loaded[10]; let __v_147: G = __loaded[11]; let __v_148: G = __loaded[12]; let __v_149: G = __loaded[13]; let __v_150: G = __loaded[14]; let __v_151: G = __loaded[15]; let __v_152: G = __loaded[16]; let __v_153: G = __loaded[17]; let __v_154: G = __loaded[18]; let __v_155: G = __loaded[19]; let __v_156: G = __loaded[20]; let __v_157: G = __loaded[21]; let __v_158: G = __loaded[22]; let __v_159: G = __loaded[23]; let __v_160: G = __loaded[24]; let __v_161: G = __loaded[25]; let __v_162: G = __loaded[26]; let __v_163: G = __loaded[27]; let __v_164: G = __loaded[28]; let __v_165: G = __loaded[29]; let __v_166: G = __loaded[30]; let __v_167: G = __loaded[31]; let __v_168: G = __loaded[32]; let __v_169: G = __loaded[33]; match __v_136.as_canonical_u64() { 1u64 => { let __v_170: G = (__v_104 * __v_33); let __v_171: G = (__v_103 + __v_170); let __v_172: G = G::from_u64(0); let __v_173: G = G::from_u64(64); let __v_174: G = G::from_u64(103); let __v_175: G = G::from_u64(230); let __v_176: G = G::from_u64(9); let __v_177: G = G::from_u64(106); let __v_178: G = G::from_u64(133); let __v_179: G = G::from_u64(174); let __v_180: G = G::from_u64(187); let __v_181: G = G::from_u64(114); let __v_182: G = G::from_u64(243); let __v_183: G = G::from_u64(110); let __v_184: G = G::from_u64(60); let __v_185: G = G::from_u64(58); let __v_186: G = G::from_u64(245); let __v_187: G = G::from_u64(79); let __v_188: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_172, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __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_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_174, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_173, __v_172, __v_172, __v_172, __v_171, __v_172, __v_172, __v_172, __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 ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_199: G = __r_arr[10]; let __v_200: G = __r_arr[11]; let __v_201: G = __r_arr[12]; let __v_202: G = __r_arr[13]; let __v_203: G = __r_arr[14]; let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; let __v_207: G = __r_arr[18]; let __v_208: G = __r_arr[19]; let __v_209: G = __r_arr[20]; let __v_210: G = __r_arr[21]; let __v_211: G = __r_arr[22]; let __v_212: G = __r_arr[23]; let __v_213: G = __r_arr[24]; let __v_214: G = __r_arr[25]; let __v_215: G = __r_arr[26]; let __v_216: G = __r_arr[27]; let __v_217: G = __r_arr[28]; let __v_218: G = __r_arr[29]; let __v_219: G = __r_arr[30]; let __v_220: G = __r_arr[31]; let __v_221: G = { let __values: [G; 34] = [__v_172, __v_102, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_221]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_170: G = G::from_u64(0); let __v_171: G = G::from_u64(64); let __v_172: G = G::from_u64(103); let __v_173: G = G::from_u64(230); let __v_174: G = G::from_u64(9); let __v_175: G = G::from_u64(106); let __v_176: G = G::from_u64(133); let __v_177: G = G::from_u64(174); let __v_178: G = G::from_u64(187); let __v_179: G = G::from_u64(114); let __v_180: G = G::from_u64(243); let __v_181: G = G::from_u64(110); let __v_182: G = G::from_u64(60); let __v_183: G = G::from_u64(58); let __v_184: G = G::from_u64(245); let __v_185: G = G::from_u64(79); let __v_186: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_170, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __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_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_172, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_171, __v_170, __v_170, __v_170, __v_103, __v_170, __v_170, __v_170, __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 ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __r_arr[1]; let __v_189: G = __r_arr[2]; let __v_190: G = __r_arr[3]; let __v_191: G = __r_arr[4]; let __v_192: G = __r_arr[5]; let __v_193: G = __r_arr[6]; let __v_194: G = __r_arr[7]; let __v_195: G = __r_arr[8]; let __v_196: G = __r_arr[9]; let __v_197: G = __r_arr[10]; let __v_198: G = __r_arr[11]; let __v_199: G = __r_arr[12]; let __v_200: G = __r_arr[13]; let __v_201: G = __r_arr[14]; let __v_202: G = __r_arr[15]; let __v_203: G = __r_arr[16]; let __v_204: G = __r_arr[17]; let __v_205: G = __r_arr[18]; let __v_206: G = __r_arr[19]; let __v_207: G = __r_arr[20]; let __v_208: G = __r_arr[21]; let __v_209: G = __r_arr[22]; let __v_210: G = __r_arr[23]; let __v_211: G = __r_arr[24]; let __v_212: G = __r_arr[25]; let __v_213: G = __r_arr[26]; let __v_214: G = __r_arr[27]; let __v_215: G = __r_arr[28]; let __v_216: G = __r_arr[29]; let __v_217: G = __r_arr[30]; let __v_218: G = __r_arr[31]; let __v_219: G = { let __values: [G; 34] = [__v_170, __v_102, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_219]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }) } +fn aiur_fn_73(inp: [G; IN_73], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __loaded[32]; let __v_67: G = __loaded[33]; match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_73] = [__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]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__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 ((!unconstrained) && record.defer_call(73, &__args[..])?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; let __v_72: G = __r_arr[3]; let __v_73: G = __r_arr[4]; let __v_74: G = __r_arr[5]; let __v_75: G = __r_arr[6]; let __v_76: G = __r_arr[7]; let __v_77: G = __r_arr[8]; let __v_78: G = __r_arr[9]; let __v_79: G = __r_arr[10]; let __v_80: G = __r_arr[11]; let __v_81: G = __r_arr[12]; let __v_82: G = __r_arr[13]; let __v_83: G = __r_arr[14]; let __v_84: G = __r_arr[15]; let __v_85: G = __r_arr[16]; let __v_86: G = __r_arr[17]; let __v_87: G = __r_arr[18]; let __v_88: G = __r_arr[19]; let __v_89: G = __r_arr[20]; let __v_90: G = __r_arr[21]; let __v_91: G = __r_arr[22]; let __v_92: G = __r_arr[23]; let __v_93: G = __r_arr[24]; let __v_94: G = __r_arr[25]; let __v_95: G = __r_arr[26]; let __v_96: G = __r_arr[27]; let __v_97: G = __r_arr[28]; let __v_98: G = __r_arr[29]; let __v_99: G = __r_arr[30]; let __v_100: G = __r_arr[31]; let __v_101: G = __r_arr[32]; let __v_102: G = __r_arr[33]; match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_73] = [__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]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_103: G = G::from_u64(4); let __v_104: G = G::from_u64(8); let __v_105: G = G::from_u64(103); let __v_106: G = G::from_u64(230); let __v_107: G = G::from_u64(9); let __v_108: G = G::from_u64(106); let __v_109: G = G::from_u64(133); let __v_110: G = G::from_u64(174); let __v_111: G = G::from_u64(187); let __v_112: G = G::from_u64(114); let __v_113: G = G::from_u64(243); let __v_114: G = G::from_u64(110); let __v_115: G = G::from_u64(60); let __v_116: G = G::from_u64(58); let __v_117: G = G::from_u64(245); let __v_118: G = G::from_u64(79); let __v_119: G = G::from_u64(165); let __v_120: G = G::from_u64(127); let __v_121: G = G::from_u64(82); let __v_122: G = G::from_u64(14); let __v_123: G = G::from_u64(81); let __v_124: G = G::from_u64(140); let __v_125: G = G::from_u64(104); let __v_126: G = G::from_u64(5); let __v_127: G = G::from_u64(155); let __v_128: G = G::from_u64(171); let __v_129: G = G::from_u64(217); let __v_130: G = G::from_u64(131); let __v_131: G = G::from_u64(31); let __v_132: G = G::from_u64(25); let __v_133: G = G::from_u64(205); let __v_134: G = G::from_u64(224); let __v_135: G = G::from_u64(91); let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; let __v_139: G = __loaded[3]; let __v_140: G = __loaded[4]; let __v_141: G = __loaded[5]; let __v_142: G = __loaded[6]; let __v_143: G = __loaded[7]; let __v_144: G = __loaded[8]; let __v_145: G = __loaded[9]; let __v_146: G = __loaded[10]; let __v_147: G = __loaded[11]; let __v_148: G = __loaded[12]; let __v_149: G = __loaded[13]; let __v_150: G = __loaded[14]; let __v_151: G = __loaded[15]; let __v_152: G = __loaded[16]; let __v_153: G = __loaded[17]; let __v_154: G = __loaded[18]; let __v_155: G = __loaded[19]; let __v_156: G = __loaded[20]; let __v_157: G = __loaded[21]; let __v_158: G = __loaded[22]; let __v_159: G = __loaded[23]; let __v_160: G = __loaded[24]; let __v_161: G = __loaded[25]; let __v_162: G = __loaded[26]; let __v_163: G = __loaded[27]; let __v_164: G = __loaded[28]; let __v_165: G = __loaded[29]; let __v_166: G = __loaded[30]; let __v_167: G = __loaded[31]; let __v_168: G = __loaded[32]; let __v_169: G = __loaded[33]; match __v_136.as_canonical_u64() { 1u64 => { let __v_170: G = __v_104 * __v_33; let __v_171: G = __v_103 + __v_170; let __v_172: G = G::from_u64(0); let __v_173: G = G::from_u64(64); let __v_174: G = G::from_u64(103); let __v_175: G = G::from_u64(230); let __v_176: G = G::from_u64(9); let __v_177: G = G::from_u64(106); let __v_178: G = G::from_u64(133); let __v_179: G = G::from_u64(174); let __v_180: G = G::from_u64(187); let __v_181: G = G::from_u64(114); let __v_182: G = G::from_u64(243); let __v_183: G = G::from_u64(110); let __v_184: G = G::from_u64(60); let __v_185: G = G::from_u64(58); let __v_186: G = G::from_u64(245); let __v_187: G = G::from_u64(79); let __v_188: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_172, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __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_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_174, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_173, __v_172, __v_172, __v_172, __v_171, __v_172, __v_172, __v_172, __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 ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_199: G = __r_arr[10]; let __v_200: G = __r_arr[11]; let __v_201: G = __r_arr[12]; let __v_202: G = __r_arr[13]; let __v_203: G = __r_arr[14]; let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; let __v_207: G = __r_arr[18]; let __v_208: G = __r_arr[19]; let __v_209: G = __r_arr[20]; let __v_210: G = __r_arr[21]; let __v_211: G = __r_arr[22]; let __v_212: G = __r_arr[23]; let __v_213: G = __r_arr[24]; let __v_214: G = __r_arr[25]; let __v_215: G = __r_arr[26]; let __v_216: G = __r_arr[27]; let __v_217: G = __r_arr[28]; let __v_218: G = __r_arr[29]; let __v_219: G = __r_arr[30]; let __v_220: G = __r_arr[31]; let __v_221: G = { let __values: [G; 34] = [__v_172, __v_102, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_221]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_170: G = G::from_u64(0); let __v_171: G = G::from_u64(64); let __v_172: G = G::from_u64(103); let __v_173: G = G::from_u64(230); let __v_174: G = G::from_u64(9); let __v_175: G = G::from_u64(106); let __v_176: G = G::from_u64(133); let __v_177: G = G::from_u64(174); let __v_178: G = G::from_u64(187); let __v_179: G = G::from_u64(114); let __v_180: G = G::from_u64(243); let __v_181: G = G::from_u64(110); let __v_182: G = G::from_u64(60); let __v_183: G = G::from_u64(58); let __v_184: G = G::from_u64(245); let __v_185: G = G::from_u64(79); let __v_186: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_170, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __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_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_172, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_171, __v_170, __v_170, __v_170, __v_103, __v_170, __v_170, __v_170, __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 ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __r_arr[1]; let __v_189: G = __r_arr[2]; let __v_190: G = __r_arr[3]; let __v_191: G = __r_arr[4]; let __v_192: G = __r_arr[5]; let __v_193: G = __r_arr[6]; let __v_194: G = __r_arr[7]; let __v_195: G = __r_arr[8]; let __v_196: G = __r_arr[9]; let __v_197: G = __r_arr[10]; let __v_198: G = __r_arr[11]; let __v_199: G = __r_arr[12]; let __v_200: G = __r_arr[13]; let __v_201: G = __r_arr[14]; let __v_202: G = __r_arr[15]; let __v_203: G = __r_arr[16]; let __v_204: G = __r_arr[17]; let __v_205: G = __r_arr[18]; let __v_206: G = __r_arr[19]; let __v_207: G = __r_arr[20]; let __v_208: G = __r_arr[21]; let __v_209: G = __r_arr[22]; let __v_210: G = __r_arr[23]; let __v_211: G = __r_arr[24]; let __v_212: G = __r_arr[25]; let __v_213: G = __r_arr[26]; let __v_214: G = __r_arr[27]; let __v_215: G = __r_arr[28]; let __v_216: G = __r_arr[29]; let __v_217: G = __r_arr[30]; let __v_218: G = __r_arr[31]; let __v_219: G = { let __values: [G; 34] = [__v_170, __v_102, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_219]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }) } const INPUT_SIZE_74: usize = 1; const IN_74: usize = 1; const OUT_74: usize = 32; -fn aiur_fn_74(inp: [G; IN_74], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = __loaded[18]; let __v_54: G = __loaded[19]; let __v_55: G = __loaded[20]; let __v_56: G = __loaded[21]; let __v_57: G = __loaded[22]; let __v_58: G = __loaded[23]; let __v_59: G = __loaded[24]; let __v_60: G = __loaded[25]; let __v_61: G = __loaded[26]; let __v_62: G = __loaded[27]; let __v_63: G = __loaded[28]; let __v_64: G = __loaded[29]; let __v_65: G = __loaded[30]; let __v_66: G = __loaded[31]; let __v_67: G = __loaded[32]; let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_74] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_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 ((!unconstrained) && record.defer_call(73, (&__args[..]))?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { (*(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73])) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; let __v_73: G = __r_arr[3]; let __v_74: G = __r_arr[4]; let __v_75: G = __r_arr[5]; let __v_76: G = __r_arr[6]; let __v_77: G = __r_arr[7]; let __v_78: G = __r_arr[8]; let __v_79: G = __r_arr[9]; let __v_80: G = __r_arr[10]; let __v_81: G = __r_arr[11]; let __v_82: G = __r_arr[12]; let __v_83: G = __r_arr[13]; let __v_84: G = __r_arr[14]; let __v_85: G = __r_arr[15]; let __v_86: G = __r_arr[16]; let __v_87: G = __r_arr[17]; let __v_88: G = __r_arr[18]; let __v_89: G = __r_arr[19]; let __v_90: G = __r_arr[20]; let __v_91: G = __r_arr[21]; let __v_92: G = __r_arr[22]; let __v_93: G = __r_arr[23]; let __v_94: G = __r_arr[24]; let __v_95: G = __r_arr[25]; let __v_96: G = __r_arr[26]; let __v_97: G = __r_arr[27]; let __v_98: G = __r_arr[28]; let __v_99: G = __r_arr[29]; let __v_100: G = __r_arr[30]; let __v_101: G = __r_arr[31]; let __v_102: G = __r_arr[32]; let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_103]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; let __v_107: G = __r_arr[3]; let __v_108: G = __r_arr[4]; let __v_109: G = __r_arr[5]; let __v_110: G = __r_arr[6]; let __v_111: G = __r_arr[7]; let __v_112: G = __r_arr[8]; let __v_113: G = __r_arr[9]; let __v_114: G = __r_arr[10]; let __v_115: G = __r_arr[11]; let __v_116: G = __r_arr[12]; let __v_117: G = __r_arr[13]; let __v_118: G = __r_arr[14]; let __v_119: G = __r_arr[15]; let __v_120: G = __r_arr[16]; let __v_121: G = __r_arr[17]; let __v_122: G = __r_arr[18]; let __v_123: G = __r_arr[19]; let __v_124: G = __r_arr[20]; let __v_125: G = __r_arr[21]; let __v_126: G = __r_arr[22]; let __v_127: G = __r_arr[23]; let __v_128: G = __r_arr[24]; let __v_129: G = __r_arr[25]; let __v_130: G = __r_arr[26]; let __v_131: G = __r_arr[27]; let __v_132: G = __r_arr[28]; 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_74] = [__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]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; 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_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; let __v_109: G = __r_arr[3]; let __v_110: G = __r_arr[4]; let __v_111: G = __r_arr[5]; let __v_112: G = __r_arr[6]; let __v_113: G = __r_arr[7]; let __v_114: G = __r_arr[8]; let __v_115: G = __r_arr[9]; let __v_116: G = __r_arr[10]; let __v_117: G = __r_arr[11]; let __v_118: G = __r_arr[12]; let __v_119: G = __r_arr[13]; let __v_120: G = __r_arr[14]; let __v_121: G = __r_arr[15]; let __v_122: G = __r_arr[16]; let __v_123: G = __r_arr[17]; let __v_124: G = __r_arr[18]; let __v_125: G = __r_arr[19]; let __v_126: G = __r_arr[20]; let __v_127: G = __r_arr[21]; let __v_128: G = __r_arr[22]; let __v_129: G = __r_arr[23]; let __v_130: G = __r_arr[24]; let __v_131: G = __r_arr[25]; let __v_132: G = __r_arr[26]; let __v_133: G = __r_arr[27]; let __v_134: G = __r_arr[28]; 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_74] = [__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]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_74(inp: [G; IN_74], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = __loaded[18]; let __v_54: G = __loaded[19]; let __v_55: G = __loaded[20]; let __v_56: G = __loaded[21]; let __v_57: G = __loaded[22]; let __v_58: G = __loaded[23]; let __v_59: G = __loaded[24]; let __v_60: G = __loaded[25]; let __v_61: G = __loaded[26]; let __v_62: G = __loaded[27]; let __v_63: G = __loaded[28]; let __v_64: G = __loaded[29]; let __v_65: G = __loaded[30]; let __v_66: G = __loaded[31]; let __v_67: G = __loaded[32]; let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_74] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_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 ((!unconstrained) && record.defer_call(73, &__args[..])?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; let __v_73: G = __r_arr[3]; let __v_74: G = __r_arr[4]; let __v_75: G = __r_arr[5]; let __v_76: G = __r_arr[6]; let __v_77: G = __r_arr[7]; let __v_78: G = __r_arr[8]; let __v_79: G = __r_arr[9]; let __v_80: G = __r_arr[10]; let __v_81: G = __r_arr[11]; let __v_82: G = __r_arr[12]; let __v_83: G = __r_arr[13]; let __v_84: G = __r_arr[14]; let __v_85: G = __r_arr[15]; let __v_86: G = __r_arr[16]; let __v_87: G = __r_arr[17]; let __v_88: G = __r_arr[18]; let __v_89: G = __r_arr[19]; let __v_90: G = __r_arr[20]; let __v_91: G = __r_arr[21]; let __v_92: G = __r_arr[22]; let __v_93: G = __r_arr[23]; let __v_94: G = __r_arr[24]; let __v_95: G = __r_arr[25]; let __v_96: G = __r_arr[26]; let __v_97: G = __r_arr[27]; let __v_98: G = __r_arr[28]; let __v_99: G = __r_arr[29]; let __v_100: G = __r_arr[30]; let __v_101: G = __r_arr[31]; let __v_102: G = __r_arr[32]; let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_103]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; let __v_107: G = __r_arr[3]; let __v_108: G = __r_arr[4]; let __v_109: G = __r_arr[5]; let __v_110: G = __r_arr[6]; let __v_111: G = __r_arr[7]; let __v_112: G = __r_arr[8]; let __v_113: G = __r_arr[9]; let __v_114: G = __r_arr[10]; let __v_115: G = __r_arr[11]; let __v_116: G = __r_arr[12]; let __v_117: G = __r_arr[13]; let __v_118: G = __r_arr[14]; let __v_119: G = __r_arr[15]; let __v_120: G = __r_arr[16]; let __v_121: G = __r_arr[17]; let __v_122: G = __r_arr[18]; let __v_123: G = __r_arr[19]; let __v_124: G = __r_arr[20]; let __v_125: G = __r_arr[21]; let __v_126: G = __r_arr[22]; let __v_127: G = __r_arr[23]; let __v_128: G = __r_arr[24]; let __v_129: G = __r_arr[25]; let __v_130: G = __r_arr[26]; let __v_131: G = __r_arr[27]; let __v_132: G = __r_arr[28]; 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_74] = [__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]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; let __v_109: G = __r_arr[3]; let __v_110: G = __r_arr[4]; let __v_111: G = __r_arr[5]; let __v_112: G = __r_arr[6]; let __v_113: G = __r_arr[7]; let __v_114: G = __r_arr[8]; let __v_115: G = __r_arr[9]; let __v_116: G = __r_arr[10]; let __v_117: G = __r_arr[11]; let __v_118: G = __r_arr[12]; let __v_119: G = __r_arr[13]; let __v_120: G = __r_arr[14]; let __v_121: G = __r_arr[15]; let __v_122: G = __r_arr[16]; let __v_123: G = __r_arr[17]; let __v_124: G = __r_arr[18]; let __v_125: G = __r_arr[19]; let __v_126: G = __r_arr[20]; let __v_127: G = __r_arr[21]; let __v_128: G = __r_arr[22]; let __v_129: G = __r_arr[23]; let __v_130: G = __r_arr[24]; let __v_131: G = __r_arr[25]; let __v_132: G = __r_arr[26]; let __v_133: G = __r_arr[27]; let __v_134: G = __r_arr[28]; 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_74] = [__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]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_75: usize = 7; const IN_75: usize = 7; const OUT_75: usize = 1; -fn aiur_fn_75(inp: [G; IN_75], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_10]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, (&__args[..]))?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { (*(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79])) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_12]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 + __v_12); let __v_14: G = (__v_3 + __v_12); let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_15]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_75(inp: [G; IN_75], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_10]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, &__args[..])?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_12]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = __v_2 + __v_12; let __v_14: G = __v_3 + __v_12; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_15]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_76: usize = 1; const IN_76: usize = 1; const OUT_76: usize = 64; -fn aiur_fn_76(inp: [G; IN_76], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_76] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_76(inp: [G; IN_76], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_76] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_77: usize = 2; const IN_77: usize = 2; const OUT_77: usize = 1; -fn aiur_fn_77(inp: [G; IN_77], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_77] = [__v_0]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_6]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_77(inp: [G; IN_77], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_77] = [__v_0]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_6]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_78: usize = 6; const IN_78: usize = 6; const OUT_78: usize = 1; -fn aiur_fn_78(inp: [G; IN_78], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = __loaded[18]; let __v_38: G = __loaded[19]; let __v_39: G = __loaded[20]; let __v_40: G = __loaded[21]; let __v_41: G = __loaded[22]; let __v_42: G = __loaded[23]; let __v_43: G = __loaded[24]; let __v_44: G = __loaded[25]; let __v_45: G = __loaded[26]; let __v_46: G = __loaded[27]; let __v_47: G = __loaded[28]; let __v_48: G = __loaded[29]; let __v_49: G = __loaded[30]; let __v_50: G = __loaded[31]; let __v_51: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; let __v_55: G = __loaded[3]; let __v_56: G = __loaded[4]; let __v_57: G = __loaded[5]; let __v_58: G = __loaded[6]; let __v_59: G = __loaded[7]; let __v_60: G = G::from_u64(103); let __v_61: G = G::from_u64(230); let __v_62: G = G::from_u64(9); let __v_63: G = G::from_u64(106); let __v_64: G = G::from_u64(133); let __v_65: G = G::from_u64(174); let __v_66: G = G::from_u64(187); let __v_67: G = G::from_u64(114); let __v_68: G = G::from_u64(243); let __v_69: G = G::from_u64(110); let __v_70: G = G::from_u64(60); let __v_71: G = G::from_u64(58); let __v_72: G = G::from_u64(245); let __v_73: G = G::from_u64(79); let __v_74: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_51, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_60, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_51, __v_51, __v_51, __v_51, __v_18, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __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 __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; let __v_78: G = __r_arr[3]; let __v_79: G = __r_arr[4]; let __v_80: G = __r_arr[5]; let __v_81: G = __r_arr[6]; let __v_82: G = __r_arr[7]; let __v_83: G = __r_arr[8]; let __v_84: G = __r_arr[9]; let __v_85: G = __r_arr[10]; let __v_86: G = __r_arr[11]; let __v_87: G = __r_arr[12]; let __v_88: G = __r_arr[13]; let __v_89: G = __r_arr[14]; let __v_90: G = __r_arr[15]; let __v_91: G = __r_arr[16]; let __v_92: G = __r_arr[17]; let __v_93: G = __r_arr[18]; let __v_94: G = __r_arr[19]; let __v_95: G = __r_arr[20]; let __v_96: G = __r_arr[21]; let __v_97: G = __r_arr[22]; let __v_98: G = __r_arr[23]; let __v_99: G = __r_arr[24]; let __v_100: G = __r_arr[25]; let __v_101: G = __r_arr[26]; let __v_102: G = __r_arr[27]; let __v_103: G = __r_arr[28]; let __v_104: G = __r_arr[29]; let __v_105: G = __r_arr[30]; let __v_106: G = __r_arr[31]; let __v_107: G = { let __values: [G; 34] = [__v_51, __v_5, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_107]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; let __v_20: G = __loaded[10]; let __v_21: G = __loaded[11]; let __v_22: G = __loaded[12]; let __v_23: G = __loaded[13]; let __v_24: G = __loaded[14]; let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; let __v_28: G = __loaded[18]; let __v_29: G = __loaded[19]; let __v_30: G = __loaded[20]; let __v_31: G = __loaded[21]; let __v_32: G = __loaded[22]; let __v_33: G = __loaded[23]; let __v_34: G = __loaded[24]; let __v_35: G = __loaded[25]; let __v_36: G = __loaded[26]; let __v_37: G = __loaded[27]; let __v_38: G = __loaded[28]; let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_42]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); let __v_20: G = G::from_bool((__v_19 == G::ZERO)); let __v_21: G = (__v_20 * __v_6); let __v_22: G = (__v_18 + __v_21); let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, (&__args[..]))?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { (*(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76])) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; let __v_33: G = __r_arr[6]; let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __v_37: G = __r_arr[10]; let __v_38: G = __r_arr[11]; let __v_39: G = __r_arr[12]; let __v_40: G = __r_arr[13]; let __v_41: G = __r_arr[14]; let __v_42: G = __r_arr[15]; let __v_43: G = __r_arr[16]; let __v_44: G = __r_arr[17]; let __v_45: G = __r_arr[18]; let __v_46: G = __r_arr[19]; let __v_47: G = __r_arr[20]; let __v_48: G = __r_arr[21]; let __v_49: G = __r_arr[22]; let __v_50: G = __r_arr[23]; let __v_51: G = __r_arr[24]; let __v_52: G = __r_arr[25]; let __v_53: G = __r_arr[26]; let __v_54: G = __r_arr[27]; let __v_55: G = __r_arr[28]; let __v_56: G = __r_arr[29]; let __v_57: G = __r_arr[30]; let __v_58: G = __r_arr[31]; let __v_59: G = __r_arr[32]; let __v_60: G = __r_arr[33]; let __v_61: G = __r_arr[34]; let __v_62: G = __r_arr[35]; let __v_63: G = __r_arr[36]; let __v_64: G = __r_arr[37]; let __v_65: G = __r_arr[38]; let __v_66: G = __r_arr[39]; let __v_67: G = __r_arr[40]; let __v_68: G = __r_arr[41]; let __v_69: G = __r_arr[42]; let __v_70: G = __r_arr[43]; let __v_71: G = __r_arr[44]; let __v_72: G = __r_arr[45]; let __v_73: G = __r_arr[46]; let __v_74: G = __r_arr[47]; let __v_75: G = __r_arr[48]; let __v_76: G = __r_arr[49]; let __v_77: G = __r_arr[50]; let __v_78: G = __r_arr[51]; let __v_79: G = __r_arr[52]; let __v_80: G = __r_arr[53]; let __v_81: G = __r_arr[54]; let __v_82: G = __r_arr[55]; let __v_83: G = __r_arr[56]; let __v_84: G = __r_arr[57]; let __v_85: G = __r_arr[58]; let __v_86: G = __r_arr[59]; let __v_87: G = __r_arr[60]; let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; let __v_94: G = __loaded[3]; let __v_95: G = __loaded[4]; let __v_96: G = __loaded[5]; let __v_97: G = __loaded[6]; let __v_98: G = __loaded[7]; let __v_99: G = __loaded[8]; let __v_100: G = __loaded[9]; let __v_101: G = __loaded[10]; let __v_102: G = __loaded[11]; let __v_103: G = __loaded[12]; let __v_104: G = __loaded[13]; let __v_105: G = __loaded[14]; let __v_106: G = __loaded[15]; let __v_107: G = __loaded[16]; let __v_108: G = __loaded[17]; let __v_109: G = __loaded[18]; let __v_110: G = __loaded[19]; let __v_111: G = __loaded[20]; let __v_112: G = __loaded[21]; let __v_113: G = __loaded[22]; let __v_114: G = __loaded[23]; let __v_115: G = __loaded[24]; let __v_116: G = __loaded[25]; let __v_117: G = __loaded[26]; let __v_118: G = __loaded[27]; let __v_119: G = __loaded[28]; let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; let __v_123: G = G::from_u64(103); let __v_124: G = G::from_u64(230); let __v_125: G = G::from_u64(9); let __v_126: G = G::from_u64(106); let __v_127: G = G::from_u64(133); let __v_128: G = G::from_u64(174); let __v_129: G = G::from_u64(187); let __v_130: G = G::from_u64(114); let __v_131: G = G::from_u64(243); let __v_132: G = G::from_u64(110); let __v_133: G = G::from_u64(60); let __v_134: G = G::from_u64(58); let __v_135: G = G::from_u64(245); let __v_136: G = G::from_u64(79); let __v_137: G = G::from_u64(165); let __v_138: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_138, __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, __v_128, __v_123, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_138, __v_138, __v_138, __v_23, __v_138, __v_138, __v_138, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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 ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; let __v_141: G = __r_arr[2]; let __v_142: G = __r_arr[3]; let __v_143: G = __r_arr[4]; let __v_144: G = __r_arr[5]; let __v_145: G = __r_arr[6]; let __v_146: G = __r_arr[7]; let __v_147: G = __r_arr[8]; let __v_148: G = __r_arr[9]; let __v_149: G = __r_arr[10]; let __v_150: G = __r_arr[11]; let __v_151: G = __r_arr[12]; let __v_152: G = __r_arr[13]; let __v_153: G = __r_arr[14]; let __v_154: G = __r_arr[15]; let __v_155: G = __r_arr[16]; let __v_156: G = __r_arr[17]; let __v_157: G = __r_arr[18]; let __v_158: G = __r_arr[19]; let __v_159: G = __r_arr[20]; let __v_160: G = __r_arr[21]; let __v_161: G = __r_arr[22]; let __v_162: G = __r_arr[23]; let __v_163: G = __r_arr[24]; let __v_164: G = __r_arr[25]; let __v_165: G = __r_arr[26]; let __v_166: G = __r_arr[27]; let __v_167: G = __r_arr[28]; let __v_168: G = __r_arr[29]; let __v_169: G = __r_arr[30]; let __v_170: G = __r_arr[31]; let __v_171: G = { let __values: [G; 34] = [__v_138, __v_5, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_171]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_78(inp: [G; IN_78], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = __v_6 + __v_7; let __v_18: G = __v_8 + __v_17; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = __loaded[18]; let __v_38: G = __loaded[19]; let __v_39: G = __loaded[20]; let __v_40: G = __loaded[21]; let __v_41: G = __loaded[22]; let __v_42: G = __loaded[23]; let __v_43: G = __loaded[24]; let __v_44: G = __loaded[25]; let __v_45: G = __loaded[26]; let __v_46: G = __loaded[27]; let __v_47: G = __loaded[28]; let __v_48: G = __loaded[29]; let __v_49: G = __loaded[30]; let __v_50: G = __loaded[31]; let __v_51: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; let __v_55: G = __loaded[3]; let __v_56: G = __loaded[4]; let __v_57: G = __loaded[5]; let __v_58: G = __loaded[6]; let __v_59: G = __loaded[7]; let __v_60: G = G::from_u64(103); let __v_61: G = G::from_u64(230); let __v_62: G = G::from_u64(9); let __v_63: G = G::from_u64(106); let __v_64: G = G::from_u64(133); let __v_65: G = G::from_u64(174); let __v_66: G = G::from_u64(187); let __v_67: G = G::from_u64(114); let __v_68: G = G::from_u64(243); let __v_69: G = G::from_u64(110); let __v_70: G = G::from_u64(60); let __v_71: G = G::from_u64(58); let __v_72: G = G::from_u64(245); let __v_73: G = G::from_u64(79); let __v_74: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_51, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_60, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_51, __v_51, __v_51, __v_51, __v_18, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __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 __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; let __v_78: G = __r_arr[3]; let __v_79: G = __r_arr[4]; let __v_80: G = __r_arr[5]; let __v_81: G = __r_arr[6]; let __v_82: G = __r_arr[7]; let __v_83: G = __r_arr[8]; let __v_84: G = __r_arr[9]; let __v_85: G = __r_arr[10]; let __v_86: G = __r_arr[11]; let __v_87: G = __r_arr[12]; let __v_88: G = __r_arr[13]; let __v_89: G = __r_arr[14]; let __v_90: G = __r_arr[15]; let __v_91: G = __r_arr[16]; let __v_92: G = __r_arr[17]; let __v_93: G = __r_arr[18]; let __v_94: G = __r_arr[19]; let __v_95: G = __r_arr[20]; let __v_96: G = __r_arr[21]; let __v_97: G = __r_arr[22]; let __v_98: G = __r_arr[23]; let __v_99: G = __r_arr[24]; let __v_100: G = __r_arr[25]; let __v_101: G = __r_arr[26]; let __v_102: G = __r_arr[27]; let __v_103: G = __r_arr[28]; let __v_104: G = __r_arr[29]; let __v_105: G = __r_arr[30]; let __v_106: G = __r_arr[31]; let __v_107: G = { let __values: [G; 34] = [__v_51, __v_5, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_107]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; let __v_20: G = __loaded[10]; let __v_21: G = __loaded[11]; let __v_22: G = __loaded[12]; let __v_23: G = __loaded[13]; let __v_24: G = __loaded[14]; let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; let __v_28: G = __loaded[18]; let __v_29: G = __loaded[19]; let __v_30: G = __loaded[20]; let __v_31: G = __loaded[21]; let __v_32: G = __loaded[22]; let __v_33: G = __loaded[23]; let __v_34: G = __loaded[24]; let __v_35: G = __loaded[25]; let __v_36: G = __loaded[26]; let __v_37: G = __loaded[27]; let __v_38: G = __loaded[28]; let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_42]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_17 * __v_8; let __v_19: G = __v_2 - __v_1; let __v_20: G = G::from_bool(__v_19 == G::ZERO); let __v_21: G = __v_20 * __v_6; let __v_22: G = __v_18 + __v_21; let __v_23: G = __v_7 + __v_22; let __v_24: G = G::from_u64(64); let __v_25: G = __v_24 - __v_1; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, &__args[..])?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; let __v_33: G = __r_arr[6]; let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __v_37: G = __r_arr[10]; let __v_38: G = __r_arr[11]; let __v_39: G = __r_arr[12]; let __v_40: G = __r_arr[13]; let __v_41: G = __r_arr[14]; let __v_42: G = __r_arr[15]; let __v_43: G = __r_arr[16]; let __v_44: G = __r_arr[17]; let __v_45: G = __r_arr[18]; let __v_46: G = __r_arr[19]; let __v_47: G = __r_arr[20]; let __v_48: G = __r_arr[21]; let __v_49: G = __r_arr[22]; let __v_50: G = __r_arr[23]; let __v_51: G = __r_arr[24]; let __v_52: G = __r_arr[25]; let __v_53: G = __r_arr[26]; let __v_54: G = __r_arr[27]; let __v_55: G = __r_arr[28]; let __v_56: G = __r_arr[29]; let __v_57: G = __r_arr[30]; let __v_58: G = __r_arr[31]; let __v_59: G = __r_arr[32]; let __v_60: G = __r_arr[33]; let __v_61: G = __r_arr[34]; let __v_62: G = __r_arr[35]; let __v_63: G = __r_arr[36]; let __v_64: G = __r_arr[37]; let __v_65: G = __r_arr[38]; let __v_66: G = __r_arr[39]; let __v_67: G = __r_arr[40]; let __v_68: G = __r_arr[41]; let __v_69: G = __r_arr[42]; let __v_70: G = __r_arr[43]; let __v_71: G = __r_arr[44]; let __v_72: G = __r_arr[45]; let __v_73: G = __r_arr[46]; let __v_74: G = __r_arr[47]; let __v_75: G = __r_arr[48]; let __v_76: G = __r_arr[49]; let __v_77: G = __r_arr[50]; let __v_78: G = __r_arr[51]; let __v_79: G = __r_arr[52]; let __v_80: G = __r_arr[53]; let __v_81: G = __r_arr[54]; let __v_82: G = __r_arr[55]; let __v_83: G = __r_arr[56]; let __v_84: G = __r_arr[57]; let __v_85: G = __r_arr[58]; let __v_86: G = __r_arr[59]; let __v_87: G = __r_arr[60]; let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; let __v_94: G = __loaded[3]; let __v_95: G = __loaded[4]; let __v_96: G = __loaded[5]; let __v_97: G = __loaded[6]; let __v_98: G = __loaded[7]; let __v_99: G = __loaded[8]; let __v_100: G = __loaded[9]; let __v_101: G = __loaded[10]; let __v_102: G = __loaded[11]; let __v_103: G = __loaded[12]; let __v_104: G = __loaded[13]; let __v_105: G = __loaded[14]; let __v_106: G = __loaded[15]; let __v_107: G = __loaded[16]; let __v_108: G = __loaded[17]; let __v_109: G = __loaded[18]; let __v_110: G = __loaded[19]; let __v_111: G = __loaded[20]; let __v_112: G = __loaded[21]; let __v_113: G = __loaded[22]; let __v_114: G = __loaded[23]; let __v_115: G = __loaded[24]; let __v_116: G = __loaded[25]; let __v_117: G = __loaded[26]; let __v_118: G = __loaded[27]; let __v_119: G = __loaded[28]; let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; let __v_123: G = G::from_u64(103); let __v_124: G = G::from_u64(230); let __v_125: G = G::from_u64(9); let __v_126: G = G::from_u64(106); let __v_127: G = G::from_u64(133); let __v_128: G = G::from_u64(174); let __v_129: G = G::from_u64(187); let __v_130: G = G::from_u64(114); let __v_131: G = G::from_u64(243); let __v_132: G = G::from_u64(110); let __v_133: G = G::from_u64(60); let __v_134: G = G::from_u64(58); let __v_135: G = G::from_u64(245); let __v_136: G = G::from_u64(79); let __v_137: G = G::from_u64(165); let __v_138: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_138, __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, __v_128, __v_123, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_138, __v_138, __v_138, __v_23, __v_138, __v_138, __v_138, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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 ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; let __v_141: G = __r_arr[2]; let __v_142: G = __r_arr[3]; let __v_143: G = __r_arr[4]; let __v_144: G = __r_arr[5]; let __v_145: G = __r_arr[6]; let __v_146: G = __r_arr[7]; let __v_147: G = __r_arr[8]; let __v_148: G = __r_arr[9]; let __v_149: G = __r_arr[10]; let __v_150: G = __r_arr[11]; let __v_151: G = __r_arr[12]; let __v_152: G = __r_arr[13]; let __v_153: G = __r_arr[14]; let __v_154: G = __r_arr[15]; let __v_155: G = __r_arr[16]; let __v_156: G = __r_arr[17]; let __v_157: G = __r_arr[18]; let __v_158: G = __r_arr[19]; let __v_159: G = __r_arr[20]; let __v_160: G = __r_arr[21]; let __v_161: G = __r_arr[22]; let __v_162: G = __r_arr[23]; let __v_163: G = __r_arr[24]; let __v_164: G = __r_arr[25]; let __v_165: G = __r_arr[26]; let __v_166: G = __r_arr[27]; let __v_167: G = __r_arr[28]; let __v_168: G = __r_arr[29]; let __v_169: G = __r_arr[30]; let __v_170: G = __r_arr[31]; let __v_171: G = { let __values: [G; 34] = [__v_138, __v_5, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_171]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_79: usize = 6; const IN_79: usize = 6; const OUT_79: usize = 1; -fn aiur_fn_79(inp: [G; IN_79], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, (&__args[..]))?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { (*(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76])) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __v_18: G = __r_arr[9]; let __v_19: G = __r_arr[10]; let __v_20: G = __r_arr[11]; let __v_21: G = __r_arr[12]; let __v_22: G = __r_arr[13]; let __v_23: G = __r_arr[14]; let __v_24: G = __r_arr[15]; let __v_25: G = __r_arr[16]; let __v_26: G = __r_arr[17]; let __v_27: G = __r_arr[18]; let __v_28: G = __r_arr[19]; let __v_29: G = __r_arr[20]; let __v_30: G = __r_arr[21]; let __v_31: G = __r_arr[22]; let __v_32: G = __r_arr[23]; let __v_33: G = __r_arr[24]; let __v_34: G = __r_arr[25]; let __v_35: G = __r_arr[26]; let __v_36: G = __r_arr[27]; let __v_37: G = __r_arr[28]; let __v_38: G = __r_arr[29]; let __v_39: G = __r_arr[30]; let __v_40: G = __r_arr[31]; let __v_41: G = __r_arr[32]; let __v_42: G = __r_arr[33]; let __v_43: G = __r_arr[34]; let __v_44: G = __r_arr[35]; let __v_45: G = __r_arr[36]; let __v_46: G = __r_arr[37]; let __v_47: G = __r_arr[38]; let __v_48: G = __r_arr[39]; let __v_49: G = __r_arr[40]; let __v_50: G = __r_arr[41]; let __v_51: G = __r_arr[42]; let __v_52: G = __r_arr[43]; let __v_53: G = __r_arr[44]; let __v_54: G = __r_arr[45]; let __v_55: G = __r_arr[46]; let __v_56: G = __r_arr[47]; let __v_57: G = __r_arr[48]; let __v_58: G = __r_arr[49]; let __v_59: G = __r_arr[50]; let __v_60: G = __r_arr[51]; let __v_61: G = __r_arr[52]; let __v_62: G = __r_arr[53]; let __v_63: G = __r_arr[54]; let __v_64: G = __r_arr[55]; let __v_65: G = __r_arr[56]; let __v_66: G = __r_arr[57]; let __v_67: G = __r_arr[58]; let __v_68: G = __r_arr[59]; let __v_69: G = __r_arr[60]; let __v_70: G = __r_arr[61]; let __v_71: G = __r_arr[62]; let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; let __v_77: G = __loaded[3]; let __v_78: G = __loaded[4]; let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); let __v_85: G = (__v_84 + __v_7); let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_117: G = __loaded[0]; let __v_118: G = __loaded[1]; let __v_119: G = __loaded[2]; let __v_120: G = __loaded[3]; let __v_121: G = __loaded[4]; let __v_122: G = __loaded[5]; let __v_123: G = __loaded[6]; let __v_124: G = __loaded[7]; let __v_125: G = __loaded[8]; let __v_126: G = __loaded[9]; let __v_127: G = __loaded[10]; let __v_128: G = __loaded[11]; let __v_129: G = __loaded[12]; let __v_130: G = __loaded[13]; let __v_131: G = __loaded[14]; let __v_132: G = __loaded[15]; let __v_133: G = __loaded[16]; let __v_134: G = __loaded[17]; let __v_135: G = __loaded[18]; let __v_136: G = __loaded[19]; let __v_137: G = __loaded[20]; let __v_138: G = __loaded[21]; let __v_139: G = __loaded[22]; let __v_140: G = __loaded[23]; let __v_141: G = __loaded[24]; let __v_142: G = __loaded[25]; let __v_143: G = __loaded[26]; let __v_144: G = __loaded[27]; let __v_145: G = __loaded[28]; let __v_146: G = __loaded[29]; let __v_147: G = __loaded[30]; let __v_148: G = __loaded[31]; let __v_149: G = G::from_u64(64); let __v_150: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_149, __v_150, __v_150, __v_150, __v_85, __v_150, __v_150, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_169: G = __r_arr[18]; let __v_170: G = __r_arr[19]; let __v_171: G = __r_arr[20]; let __v_172: G = __r_arr[21]; let __v_173: G = __r_arr[22]; let __v_174: G = __r_arr[23]; let __v_175: G = __r_arr[24]; let __v_176: G = __r_arr[25]; let __v_177: G = __r_arr[26]; let __v_178: G = __r_arr[27]; let __v_179: G = __r_arr[28]; let __v_180: G = __r_arr[29]; let __v_181: G = __r_arr[30]; let __v_182: G = __r_arr[31]; let __v_183: G = { let __values: [G; 34] = [__v_150, __v_5, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_184: G = G::from_u64(1); let __v_185: G = { let __values: [G; 3] = [__v_184, __v_184, __v_184]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, (&__args[..]))?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { (*(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11])) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = __r_arr[3]; let __v_190: G = __r_arr[4]; let __v_191: G = __r_arr[5]; let __v_192: G = __r_arr[6]; let __v_193: G = __r_arr[7]; let __v_194: G = { let __values: [G; 8] = [__v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_195: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __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]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_196]; record.function_queries[79].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; let __v_79: G = __loaded[3]; let __v_80: G = __loaded[4]; let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); let __v_87: G = G::from_u64(63); let __v_88: G = (__v_2 - __v_87); let __v_89: G = G::from_bool((__v_88 == G::ZERO)); let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; let __v_96: G = __loaded[3]; let __v_97: G = __loaded[4]; let __v_98: G = __loaded[5]; let __v_99: G = __loaded[6]; let __v_100: G = __loaded[7]; let __v_101: G = __loaded[8]; let __v_102: G = __loaded[9]; let __v_103: G = __loaded[10]; let __v_104: G = __loaded[11]; let __v_105: G = __loaded[12]; let __v_106: G = __loaded[13]; let __v_107: G = __loaded[14]; let __v_108: G = __loaded[15]; let __v_109: G = __loaded[16]; let __v_110: G = __loaded[17]; let __v_111: G = __loaded[18]; let __v_112: G = __loaded[19]; let __v_113: G = __loaded[20]; let __v_114: G = __loaded[21]; let __v_115: G = __loaded[22]; let __v_116: G = __loaded[23]; let __v_117: G = __loaded[24]; let __v_118: G = __loaded[25]; let __v_119: G = __loaded[26]; let __v_120: G = __loaded[27]; let __v_121: G = __loaded[28]; let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; let __v_125: G = G::from_u64(64); let __v_126: G = G::from_u64(103); let __v_127: G = G::from_u64(230); let __v_128: G = G::from_u64(9); let __v_129: G = G::from_u64(106); let __v_130: G = G::from_u64(133); let __v_131: G = G::from_u64(174); let __v_132: G = G::from_u64(187); let __v_133: G = G::from_u64(114); let __v_134: G = G::from_u64(243); let __v_135: G = G::from_u64(110); let __v_136: G = G::from_u64(60); let __v_137: G = G::from_u64(58); let __v_138: G = G::from_u64(245); let __v_139: G = G::from_u64(79); let __v_140: G = G::from_u64(165); let __v_141: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_141, __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_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_126, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_125, __v_141, __v_141, __v_141, __v_92, __v_141, __v_141, __v_141, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __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 ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __v_152: G = __r_arr[10]; let __v_153: G = __r_arr[11]; let __v_154: G = __r_arr[12]; let __v_155: G = __r_arr[13]; let __v_156: G = __r_arr[14]; let __v_157: G = __r_arr[15]; let __v_158: G = __r_arr[16]; let __v_159: G = __r_arr[17]; let __v_160: G = __r_arr[18]; let __v_161: G = __r_arr[19]; let __v_162: G = __r_arr[20]; let __v_163: G = __r_arr[21]; let __v_164: G = __r_arr[22]; let __v_165: G = __r_arr[23]; let __v_166: G = __r_arr[24]; let __v_167: G = __r_arr[25]; let __v_168: G = __r_arr[26]; let __v_169: G = __r_arr[27]; let __v_170: G = __r_arr[28]; let __v_171: G = __r_arr[29]; let __v_172: G = __r_arr[30]; let __v_173: G = __r_arr[31]; let __v_174: G = G::from_u64(1); let __v_175: G = { let __values: [G; 3] = [__v_174, __v_174, __v_174]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_176: G = (__v_2 + __v_174); let __v_177: G = { let __values: [G; 32] = [__v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_178: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_178]; record.function_queries[79].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_79(inp: [G; IN_79], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, &__args[..])?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __v_18: G = __r_arr[9]; let __v_19: G = __r_arr[10]; let __v_20: G = __r_arr[11]; let __v_21: G = __r_arr[12]; let __v_22: G = __r_arr[13]; let __v_23: G = __r_arr[14]; let __v_24: G = __r_arr[15]; let __v_25: G = __r_arr[16]; let __v_26: G = __r_arr[17]; let __v_27: G = __r_arr[18]; let __v_28: G = __r_arr[19]; let __v_29: G = __r_arr[20]; let __v_30: G = __r_arr[21]; let __v_31: G = __r_arr[22]; let __v_32: G = __r_arr[23]; let __v_33: G = __r_arr[24]; let __v_34: G = __r_arr[25]; let __v_35: G = __r_arr[26]; let __v_36: G = __r_arr[27]; let __v_37: G = __r_arr[28]; let __v_38: G = __r_arr[29]; let __v_39: G = __r_arr[30]; let __v_40: G = __r_arr[31]; let __v_41: G = __r_arr[32]; let __v_42: G = __r_arr[33]; let __v_43: G = __r_arr[34]; let __v_44: G = __r_arr[35]; let __v_45: G = __r_arr[36]; let __v_46: G = __r_arr[37]; let __v_47: G = __r_arr[38]; let __v_48: G = __r_arr[39]; let __v_49: G = __r_arr[40]; let __v_50: G = __r_arr[41]; let __v_51: G = __r_arr[42]; let __v_52: G = __r_arr[43]; let __v_53: G = __r_arr[44]; let __v_54: G = __r_arr[45]; let __v_55: G = __r_arr[46]; let __v_56: G = __r_arr[47]; let __v_57: G = __r_arr[48]; let __v_58: G = __r_arr[49]; let __v_59: G = __r_arr[50]; let __v_60: G = __r_arr[51]; let __v_61: G = __r_arr[52]; let __v_62: G = __r_arr[53]; let __v_63: G = __r_arr[54]; let __v_64: G = __r_arr[55]; let __v_65: G = __r_arr[56]; let __v_66: G = __r_arr[57]; let __v_67: G = __r_arr[58]; let __v_68: G = __r_arr[59]; let __v_69: G = __r_arr[60]; let __v_70: G = __r_arr[61]; let __v_71: G = __r_arr[62]; let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; let __v_77: G = __loaded[3]; let __v_78: G = __loaded[4]; let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __v_73 * __v_82; let __v_84: G = __v_8 * __v_83; let __v_85: G = __v_84 + __v_7; let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_117: G = __loaded[0]; let __v_118: G = __loaded[1]; let __v_119: G = __loaded[2]; let __v_120: G = __loaded[3]; let __v_121: G = __loaded[4]; let __v_122: G = __loaded[5]; let __v_123: G = __loaded[6]; let __v_124: G = __loaded[7]; let __v_125: G = __loaded[8]; let __v_126: G = __loaded[9]; let __v_127: G = __loaded[10]; let __v_128: G = __loaded[11]; let __v_129: G = __loaded[12]; let __v_130: G = __loaded[13]; let __v_131: G = __loaded[14]; let __v_132: G = __loaded[15]; let __v_133: G = __loaded[16]; let __v_134: G = __loaded[17]; let __v_135: G = __loaded[18]; let __v_136: G = __loaded[19]; let __v_137: G = __loaded[20]; let __v_138: G = __loaded[21]; let __v_139: G = __loaded[22]; let __v_140: G = __loaded[23]; let __v_141: G = __loaded[24]; let __v_142: G = __loaded[25]; let __v_143: G = __loaded[26]; let __v_144: G = __loaded[27]; let __v_145: G = __loaded[28]; let __v_146: G = __loaded[29]; let __v_147: G = __loaded[30]; let __v_148: G = __loaded[31]; let __v_149: G = G::from_u64(64); let __v_150: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_149, __v_150, __v_150, __v_150, __v_85, __v_150, __v_150, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_169: G = __r_arr[18]; let __v_170: G = __r_arr[19]; let __v_171: G = __r_arr[20]; let __v_172: G = __r_arr[21]; let __v_173: G = __r_arr[22]; let __v_174: G = __r_arr[23]; let __v_175: G = __r_arr[24]; let __v_176: G = __r_arr[25]; let __v_177: G = __r_arr[26]; let __v_178: G = __r_arr[27]; let __v_179: G = __r_arr[28]; let __v_180: G = __r_arr[29]; let __v_181: G = __r_arr[30]; let __v_182: G = __r_arr[31]; let __v_183: G = { let __values: [G; 34] = [__v_150, __v_5, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_184: G = G::from_u64(1); let __v_185: G = { let __values: [G; 3] = [__v_184, __v_184, __v_184]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, &__args[..])?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { *(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11]) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = __r_arr[3]; let __v_190: G = __r_arr[4]; let __v_191: G = __r_arr[5]; let __v_192: G = __r_arr[6]; let __v_193: G = __r_arr[7]; let __v_194: G = { let __values: [G; 8] = [__v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_195: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __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]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_196]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __v_73 * __v_7; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; let __v_79: G = __loaded[3]; let __v_80: G = __loaded[4]; let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __v_84 * __v_8; let __v_86: G = __v_75 * __v_85; let __v_87: G = G::from_u64(63); let __v_88: G = __v_2 - __v_87; let __v_89: G = G::from_bool(__v_88 == G::ZERO); let __v_90: G = __v_89 * __v_6; let __v_91: G = __v_86 + __v_90; let __v_92: G = __v_74 + __v_91; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; let __v_96: G = __loaded[3]; let __v_97: G = __loaded[4]; let __v_98: G = __loaded[5]; let __v_99: G = __loaded[6]; let __v_100: G = __loaded[7]; let __v_101: G = __loaded[8]; let __v_102: G = __loaded[9]; let __v_103: G = __loaded[10]; let __v_104: G = __loaded[11]; let __v_105: G = __loaded[12]; let __v_106: G = __loaded[13]; let __v_107: G = __loaded[14]; let __v_108: G = __loaded[15]; let __v_109: G = __loaded[16]; let __v_110: G = __loaded[17]; let __v_111: G = __loaded[18]; let __v_112: G = __loaded[19]; let __v_113: G = __loaded[20]; let __v_114: G = __loaded[21]; let __v_115: G = __loaded[22]; let __v_116: G = __loaded[23]; let __v_117: G = __loaded[24]; let __v_118: G = __loaded[25]; let __v_119: G = __loaded[26]; let __v_120: G = __loaded[27]; let __v_121: G = __loaded[28]; let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; let __v_125: G = G::from_u64(64); let __v_126: G = G::from_u64(103); let __v_127: G = G::from_u64(230); let __v_128: G = G::from_u64(9); let __v_129: G = G::from_u64(106); let __v_130: G = G::from_u64(133); let __v_131: G = G::from_u64(174); let __v_132: G = G::from_u64(187); let __v_133: G = G::from_u64(114); let __v_134: G = G::from_u64(243); let __v_135: G = G::from_u64(110); let __v_136: G = G::from_u64(60); let __v_137: G = G::from_u64(58); let __v_138: G = G::from_u64(245); let __v_139: G = G::from_u64(79); let __v_140: G = G::from_u64(165); let __v_141: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_141, __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_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_126, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_125, __v_141, __v_141, __v_141, __v_92, __v_141, __v_141, __v_141, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __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 ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __v_152: G = __r_arr[10]; let __v_153: G = __r_arr[11]; let __v_154: G = __r_arr[12]; let __v_155: G = __r_arr[13]; let __v_156: G = __r_arr[14]; let __v_157: G = __r_arr[15]; let __v_158: G = __r_arr[16]; let __v_159: G = __r_arr[17]; let __v_160: G = __r_arr[18]; let __v_161: G = __r_arr[19]; let __v_162: G = __r_arr[20]; let __v_163: G = __r_arr[21]; let __v_164: G = __r_arr[22]; let __v_165: G = __r_arr[23]; let __v_166: G = __r_arr[24]; let __v_167: G = __r_arr[25]; let __v_168: G = __r_arr[26]; let __v_169: G = __r_arr[27]; let __v_170: G = __r_arr[28]; let __v_171: G = __r_arr[29]; let __v_172: G = __r_arr[30]; let __v_173: G = __r_arr[31]; let __v_174: G = G::from_u64(1); let __v_175: G = { let __values: [G; 3] = [__v_174, __v_174, __v_174]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_176: G = __v_2 + __v_174; let __v_177: G = { let __values: [G; 32] = [__v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_178: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_178]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_80: usize = 24; const IN_80: usize = 24; const OUT_80: usize = 16; -fn aiur_fn_80(inp: [G; IN_80], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __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_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; 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_26; let __vj = __v_27; 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_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(2); let __v_32: G = (__v_28 - __v_31); let __v_33: G = (__v_30 * __v_32); let __v_34: G = (__v_28 * __v_33); let __v_35: G = G::from_u64(0); if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_36: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_12), (&__v_24)) } else { aiur::execute::bytes2_xor_value(__v_12, __v_24, record) }; let __v_37: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_13), (&__v_25)) } else { aiur::execute::bytes2_xor_value(__v_13, __v_25, record) }; let __v_38: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_14), (&__v_26)) } else { aiur::execute::bytes2_xor_value(__v_14, __v_26, record) }; let __v_39: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_15), (&__v_27)) } else { aiur::execute::bytes2_xor_value(__v_15, __v_27, record) }; let __u32_sum: u128 = (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))) + u128::from(((((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8)) | (__v_36.as_canonical_u64() << 16)) | (__v_37.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); let __v_41: G = G::from_u8(__u32_bytes[1]); let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); 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)); } let __v_45: G = (__v_44 * __v_44); if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_4), (&__v_40)) } else { aiur::execute::bytes2_xor_split4_value(__v_4, __v_40, record) }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_5), (&__v_41)) } else { aiur::execute::bytes2_xor_split4_value(__v_5, __v_41, record) }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_6), (&__v_42)) } else { aiur::execute::bytes2_xor_split4_value(__v_6, __v_42, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_7), (&__v_43)) } else { aiur::execute::bytes2_xor_split4_value(__v_7, __v_43, record) }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = (__v_48 + __v_51); let __v_55: G = (__v_50 + __v_53); let __v_56: G = (__v_52 + __v_47); let __v_57: G = (__v_46 + __v_49); let __u32_sum: u128 = ((u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24))) + u128::from(((((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8)) | (__v_56.as_canonical_u64() << 16)) | (__v_57.as_canonical_u64() << 24)))) + u128::from(((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_58: G = G::from_u8(__u32_bytes[0]); let __v_59: G = G::from_u8(__u32_bytes[1]); let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); 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)); } let __v_63: G = (__v_62 - __v_29); let __v_64: G = (__v_62 - __v_31); let __v_65: G = (__v_63 * __v_64); let __v_66: G = (__v_62 * __v_65); if (__v_66 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_67: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_38), (&__v_58)) } else { aiur::execute::bytes2_xor_value(__v_38, __v_58, record) }; let __v_68: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_39), (&__v_59)) } else { aiur::execute::bytes2_xor_value(__v_39, __v_59, record) }; let __v_69: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_36), (&__v_60)) } else { aiur::execute::bytes2_xor_value(__v_36, __v_60, record) }; let __v_70: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_37), (&__v_61)) } else { aiur::execute::bytes2_xor_value(__v_37, __v_61, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_71: G = G::from_u8(__u32_bytes[0]); let __v_72: G = G::from_u8(__u32_bytes[1]); let __v_73: G = G::from_u8(__u32_bytes[2]); let __v_74: G = G::from_u8(__u32_bytes[3]); let __v_75: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); 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)); } let __v_76: G = (__v_75 * __v_75); if (__v_76 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_54), (&__v_71)) } else { aiur::execute::bytes2_xor_split7_value(__v_54, __v_71, record) }; let __v_77: G = __b2_out.0; let __v_78: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_55), (&__v_72)) } else { aiur::execute::bytes2_xor_split7_value(__v_55, __v_72, record) }; let __v_79: G = __b2_out.0; let __v_80: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_56), (&__v_73)) } else { aiur::execute::bytes2_xor_split7_value(__v_56, __v_73, record) }; let __v_81: G = __b2_out.0; let __v_82: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_57), (&__v_74)) } else { aiur::execute::bytes2_xor_split7_value(__v_57, __v_74, record) }; let __v_83: G = __b2_out.0; let __v_84: G = __b2_out.1; let __v_85: G = (__v_77 + __v_80); let __v_86: G = (__v_79 + __v_82); let __v_87: G = (__v_81 + __v_84); let __v_88: G = (__v_83 + __v_78); let __ret: [G; OUT_80] = [__v_58, __v_59, __v_60, __v_61, __v_85, __v_86, __v_87, __v_88, __v_71, __v_72, __v_73, __v_74, __v_68, __v_69, __v_70, __v_67]; record.function_queries[80].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_80(inp: [G; IN_80], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __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_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; 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_26; let __vj = __v_27; 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_29: G = G::from_u64(1); let __v_30: G = __v_28 - __v_29; let __v_31: G = G::from_u64(2); let __v_32: G = __v_28 - __v_31; let __v_33: G = __v_30 * __v_32; let __v_34: G = __v_28 * __v_33; let __v_35: G = G::from_u64(0); if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_36: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_12, &__v_24) } else { aiur::execute::bytes2_xor_value(__v_12, __v_24, record) }; let __v_37: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_13, &__v_25) } else { aiur::execute::bytes2_xor_value(__v_13, __v_25, record) }; let __v_38: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_14, &__v_26) } else { aiur::execute::bytes2_xor_value(__v_14, __v_26, record) }; let __v_39: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_15, &__v_27) } else { aiur::execute::bytes2_xor_value(__v_15, __v_27, record) }; let __u32_sum: u128 = 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)) + u128::from((((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8)) | (__v_36.as_canonical_u64() << 16)) | (__v_37.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); let __v_41: G = G::from_u8(__u32_bytes[1]); let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); 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); } let __v_45: G = __v_44 * __v_44; if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_4, &__v_40) } else { aiur::execute::bytes2_xor_split4_value(__v_4, __v_40, record) }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_5, &__v_41) } else { aiur::execute::bytes2_xor_split4_value(__v_5, __v_41, record) }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_6, &__v_42) } else { aiur::execute::bytes2_xor_split4_value(__v_6, __v_42, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_7, &__v_43) } else { aiur::execute::bytes2_xor_split4_value(__v_7, __v_43, record) }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = __v_48 + __v_51; let __v_55: G = __v_50 + __v_53; let __v_56: G = __v_52 + __v_47; let __v_57: G = __v_46 + __v_49; let __u32_sum: u128 = (u128::from((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24)) + u128::from((((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8)) | (__v_56.as_canonical_u64() << 16)) | (__v_57.as_canonical_u64() << 24))) + u128::from((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_58: G = G::from_u8(__u32_bytes[0]); let __v_59: G = G::from_u8(__u32_bytes[1]); let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); 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); } let __v_63: G = __v_62 - __v_29; let __v_64: G = __v_62 - __v_31; let __v_65: G = __v_63 * __v_64; let __v_66: G = __v_62 * __v_65; if (__v_66 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_67: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_38, &__v_58) } else { aiur::execute::bytes2_xor_value(__v_38, __v_58, record) }; let __v_68: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_39, &__v_59) } else { aiur::execute::bytes2_xor_value(__v_39, __v_59, record) }; let __v_69: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_36, &__v_60) } else { aiur::execute::bytes2_xor_value(__v_36, __v_60, record) }; let __v_70: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_37, &__v_61) } else { aiur::execute::bytes2_xor_value(__v_37, __v_61, record) }; let __u32_sum: u128 = u128::from((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24)) + u128::from((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_71: G = G::from_u8(__u32_bytes[0]); let __v_72: G = G::from_u8(__u32_bytes[1]); let __v_73: G = G::from_u8(__u32_bytes[2]); let __v_74: G = G::from_u8(__u32_bytes[3]); let __v_75: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); 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); } let __v_76: G = __v_75 * __v_75; if (__v_76 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_54, &__v_71) } else { aiur::execute::bytes2_xor_split7_value(__v_54, __v_71, record) }; let __v_77: G = __b2_out.0; let __v_78: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_55, &__v_72) } else { aiur::execute::bytes2_xor_split7_value(__v_55, __v_72, record) }; let __v_79: G = __b2_out.0; let __v_80: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_56, &__v_73) } else { aiur::execute::bytes2_xor_split7_value(__v_56, __v_73, record) }; let __v_81: G = __b2_out.0; let __v_82: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_57, &__v_74) } else { aiur::execute::bytes2_xor_split7_value(__v_57, __v_74, record) }; let __v_83: G = __b2_out.0; let __v_84: G = __b2_out.1; let __v_85: G = __v_77 + __v_80; let __v_86: G = __v_79 + __v_82; let __v_87: G = __v_81 + __v_84; let __v_88: G = __v_83 + __v_78; let __ret: [G; OUT_80] = [__v_58, __v_59, __v_60, __v_61, __v_85, __v_86, __v_87, __v_88, __v_71, __v_72, __v_73, __v_74, __v_68, __v_69, __v_70, __v_67]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_81: usize = 128; const IN_81: usize = 128; const OUT_81: usize = 128; -fn aiur_fn_81(inp: [G; IN_81], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __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_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))) + u128::from(((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; 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_130; let __vj = __v_131; 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_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = G::from_u64(2); let __v_136: G = (__v_132 - __v_135); let __v_137: G = (__v_134 * __v_136); let __v_138: G = (__v_132 * __v_137); let __v_139: G = G::from_u64(0); if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_48), (&__v_128)) } else { aiur::execute::bytes2_xor_value(__v_48, __v_128, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __u32_sum: u128 = (u128::from(((((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8)) | (__v_34.as_canonical_u64() << 16)) | (__v_35.as_canonical_u64() << 24))) + u128::from(((((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8)) | (__v_140.as_canonical_u64() << 16)) | (__v_141.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); let __v_145: G = G::from_u8(__u32_bytes[1]); let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; 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_146; let __vj = __v_147; 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_149: G = (__v_148 * __v_148); if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_16), (&__v_144)) } else { aiur::execute::bytes2_xor_split4_value(__v_16, __v_144, record) }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = (__v_152 + __v_155); let __v_159: G = (__v_154 + __v_157); let __v_160: G = (__v_156 + __v_151); let __v_161: G = (__v_150 + __v_153); let __u32_sum: u128 = ((u128::from(((((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8)) | (__v_130.as_canonical_u64() << 16)) | (__v_131.as_canonical_u64() << 24))) + u128::from(((((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8)) | (__v_160.as_canonical_u64() << 16)) | (__v_161.as_canonical_u64() << 24)))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_71.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_162: G = G::from_u8(__u32_bytes[0]); let __v_163: G = G::from_u8(__u32_bytes[1]); let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_162; let __vj = __v_163; 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_164; let __vj = __v_165; 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_167: G = (__v_166 - __v_133); let __v_168: G = (__v_166 - __v_135); let __v_169: G = (__v_167 * __v_168); let __v_170: G = (__v_166 * __v_169); if (__v_170 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_171: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_162)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_162, record) }; let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_140), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_140, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __u32_sum: u128 = (u128::from(((((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8)) | (__v_146.as_canonical_u64() << 16)) | (__v_147.as_canonical_u64() << 24))) + u128::from(((((__v_172.as_canonical_u64() << 0) | (__v_173.as_canonical_u64() << 8)) | (__v_174.as_canonical_u64() << 16)) | (__v_171.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_175: G = G::from_u8(__u32_bytes[0]); let __v_176: G = G::from_u8(__u32_bytes[1]); let __v_177: G = G::from_u8(__u32_bytes[2]); let __v_178: G = G::from_u8(__u32_bytes[3]); let __v_179: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_175; let __vj = __v_176; 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_177; let __vj = __v_178; 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_180: G = (__v_179 * __v_179); if (__v_180 != __v_179) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_179.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_158), (&__v_175)) } else { aiur::execute::bytes2_xor_split7_value(__v_158, __v_175, record) }; let __v_181: G = __b2_out.0; let __v_182: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_183: G = __b2_out.0; let __v_184: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; let __v_189: G = (__v_181 + __v_184); let __v_190: G = (__v_183 + __v_186); let __v_191: G = (__v_185 + __v_188); let __v_192: G = (__v_187 + __v_182); let __u32_sum: u128 = ((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_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))) + u128::from(((((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8)) | (__v_74.as_canonical_u64() << 16)) | (__v_75.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_193: G = G::from_u8(__u32_bytes[0]); let __v_194: G = G::from_u8(__u32_bytes[1]); let __v_195: G = G::from_u8(__u32_bytes[2]); let __v_196: G = G::from_u8(__u32_bytes[3]); let __v_197: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_193; let __vj = __v_194; 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_195; let __vj = __v_196; 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_198: G = (__v_197 - __v_133); let __v_199: G = (__v_197 - __v_135); let __v_200: G = (__v_198 * __v_199); let __v_201: G = (__v_197 * __v_200); if (__v_201 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_202: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_193)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_193, record) }; let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __u32_sum: u128 = (u128::from(((((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8)) | (__v_38.as_canonical_u64() << 16)) | (__v_39.as_canonical_u64() << 24))) + u128::from(((((__v_204.as_canonical_u64() << 0) | (__v_205.as_canonical_u64() << 8)) | (__v_202.as_canonical_u64() << 16)) | (__v_203.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_206: G = G::from_u8(__u32_bytes[0]); let __v_207: G = G::from_u8(__u32_bytes[1]); let __v_208: G = G::from_u8(__u32_bytes[2]); let __v_209: G = G::from_u8(__u32_bytes[3]); let __v_210: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_206; let __vj = __v_207; 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_208; let __vj = __v_209; 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_211: G = (__v_210 * __v_210); if (__v_211 != __v_210) { return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_210.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_206)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_206, record) }; let __v_212: G = __b2_out.0; let __v_213: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_214: G = __b2_out.0; let __v_215: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_216: G = __b2_out.0; let __v_217: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; let __v_220: G = (__v_214 + __v_217); let __v_221: G = (__v_216 + __v_219); let __v_222: G = (__v_218 + __v_213); let __v_223: G = (__v_212 + __v_215); let __u32_sum: u128 = ((u128::from(((((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8)) | (__v_195.as_canonical_u64() << 16)) | (__v_196.as_canonical_u64() << 24))) + u128::from(((((__v_220.as_canonical_u64() << 0) | (__v_221.as_canonical_u64() << 8)) | (__v_222.as_canonical_u64() << 16)) | (__v_223.as_canonical_u64() << 24)))) + u128::from(((((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8)) | (__v_78.as_canonical_u64() << 16)) | (__v_79.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_224: G = G::from_u8(__u32_bytes[0]); let __v_225: G = G::from_u8(__u32_bytes[1]); let __v_226: G = G::from_u8(__u32_bytes[2]); let __v_227: G = G::from_u8(__u32_bytes[3]); let __v_228: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_224; let __vj = __v_225; 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_226; let __vj = __v_227; 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_229: G = (__v_228 - __v_133); let __v_230: G = (__v_228 - __v_135); let __v_231: G = (__v_229 * __v_230); let __v_232: G = (__v_228 * __v_231); if (__v_232 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_233: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_224)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_224, record) }; let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_202), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_202, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __u32_sum: u128 = (u128::from(((((__v_206.as_canonical_u64() << 0) | (__v_207.as_canonical_u64() << 8)) | (__v_208.as_canonical_u64() << 16)) | (__v_209.as_canonical_u64() << 24))) + u128::from(((((__v_234.as_canonical_u64() << 0) | (__v_235.as_canonical_u64() << 8)) | (__v_236.as_canonical_u64() << 16)) | (__v_233.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_237: G = G::from_u8(__u32_bytes[0]); let __v_238: G = G::from_u8(__u32_bytes[1]); let __v_239: G = G::from_u8(__u32_bytes[2]); let __v_240: G = G::from_u8(__u32_bytes[3]); let __v_241: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; 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_239; let __vj = __v_240; 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_242: G = (__v_241 * __v_241); if (__v_242 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_220), (&__v_237)) } else { aiur::execute::bytes2_xor_split7_value(__v_220, __v_237, record) }; let __v_243: G = __b2_out.0; let __v_244: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_245: G = __b2_out.0; let __v_246: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_247: G = __b2_out.0; let __v_248: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_249: G = __b2_out.0; let __v_250: G = __b2_out.1; let __v_251: G = (__v_243 + __v_246); let __v_252: G = (__v_245 + __v_248); let __v_253: G = (__v_247 + __v_250); let __v_254: G = (__v_249 + __v_244); let __u32_sum: u128 = ((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))) + u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24)))) + u128::from(((((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8)) | (__v_82.as_canonical_u64() << 16)) | (__v_83.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_255: G = G::from_u8(__u32_bytes[0]); let __v_256: G = G::from_u8(__u32_bytes[1]); let __v_257: G = G::from_u8(__u32_bytes[2]); let __v_258: G = G::from_u8(__u32_bytes[3]); let __v_259: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_255; let __vj = __v_256; 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_257; let __vj = __v_258; 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_260: G = (__v_259 - __v_133); let __v_261: G = (__v_259 - __v_135); let __v_262: G = (__v_260 * __v_261); let __v_263: G = (__v_259 * __v_262); if (__v_263 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_263.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_264: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_255)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_255, record) }; let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_266.as_canonical_u64() << 0) | (__v_267.as_canonical_u64() << 8)) | (__v_264.as_canonical_u64() << 16)) | (__v_265.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_268: G = G::from_u8(__u32_bytes[0]); let __v_269: G = G::from_u8(__u32_bytes[1]); let __v_270: G = G::from_u8(__u32_bytes[2]); let __v_271: G = G::from_u8(__u32_bytes[3]); let __v_272: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; 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_270; let __vj = __v_271; 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_273: G = (__v_272 * __v_272); if (__v_273 != __v_272) { return Err(ExecError::AssertEqMismatch { lhs: __v_273.as_canonical_u64(), rhs: __v_272.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_268)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_268, record) }; let __v_274: G = __b2_out.0; let __v_275: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_276: G = __b2_out.0; let __v_277: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_278: G = __b2_out.0; let __v_279: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_280: G = __b2_out.0; let __v_281: G = __b2_out.1; let __v_282: G = (__v_276 + __v_279); let __v_283: G = (__v_278 + __v_281); let __v_284: G = (__v_280 + __v_275); let __v_285: G = (__v_274 + __v_277); let __u32_sum: u128 = ((u128::from(((((__v_255.as_canonical_u64() << 0) | (__v_256.as_canonical_u64() << 8)) | (__v_257.as_canonical_u64() << 16)) | (__v_258.as_canonical_u64() << 24))) + u128::from(((((__v_282.as_canonical_u64() << 0) | (__v_283.as_canonical_u64() << 8)) | (__v_284.as_canonical_u64() << 16)) | (__v_285.as_canonical_u64() << 24)))) + u128::from(((((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8)) | (__v_86.as_canonical_u64() << 16)) | (__v_87.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_286: G = G::from_u8(__u32_bytes[0]); let __v_287: G = G::from_u8(__u32_bytes[1]); let __v_288: G = G::from_u8(__u32_bytes[2]); let __v_289: G = G::from_u8(__u32_bytes[3]); let __v_290: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_286; let __vj = __v_287; 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_288; let __vj = __v_289; 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_291: G = (__v_290 - __v_133); let __v_292: G = (__v_290 - __v_135); let __v_293: G = (__v_291 * __v_292); let __v_294: G = (__v_290 * __v_293); if (__v_294 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_294.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_295: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_286)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_286, record) }; let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_264), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_264, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __u32_sum: u128 = (u128::from(((((__v_268.as_canonical_u64() << 0) | (__v_269.as_canonical_u64() << 8)) | (__v_270.as_canonical_u64() << 16)) | (__v_271.as_canonical_u64() << 24))) + u128::from(((((__v_296.as_canonical_u64() << 0) | (__v_297.as_canonical_u64() << 8)) | (__v_298.as_canonical_u64() << 16)) | (__v_295.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_299: G = G::from_u8(__u32_bytes[0]); let __v_300: G = G::from_u8(__u32_bytes[1]); let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_299; let __vj = __v_300; 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_301; let __vj = __v_302; 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_304: G = (__v_303 * __v_303); if (__v_304 != __v_303) { return Err(ExecError::AssertEqMismatch { lhs: __v_304.as_canonical_u64(), rhs: __v_303.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_282), (&__v_299)) } else { aiur::execute::bytes2_xor_split7_value(__v_282, __v_299, record) }; let __v_305: G = __b2_out.0; let __v_306: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_307: G = __b2_out.0; let __v_308: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_309: G = __b2_out.0; let __v_310: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_311: G = __b2_out.0; let __v_312: G = __b2_out.1; let __v_313: G = (__v_305 + __v_308); let __v_314: G = (__v_307 + __v_310); let __v_315: G = (__v_309 + __v_312); let __v_316: G = (__v_311 + __v_306); let __u32_sum: u128 = ((u128::from(((((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8)) | (__v_14.as_canonical_u64() << 16)) | (__v_15.as_canonical_u64() << 24))) + u128::from(((((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8)) | (__v_30.as_canonical_u64() << 16)) | (__v_31.as_canonical_u64() << 24)))) + u128::from(((((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8)) | (__v_90.as_canonical_u64() << 16)) | (__v_91.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_317: G = G::from_u8(__u32_bytes[0]); let __v_318: G = G::from_u8(__u32_bytes[1]); let __v_319: G = G::from_u8(__u32_bytes[2]); let __v_320: G = G::from_u8(__u32_bytes[3]); let __v_321: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_317; let __vj = __v_318; 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_319; let __vj = __v_320; 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_322: G = (__v_321 - __v_133); let __v_323: G = (__v_321 - __v_135); let __v_324: G = (__v_322 * __v_323); let __v_325: G = (__v_321 * __v_324); if (__v_325 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_325.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_326: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_317)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_317, record) }; let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __u32_sum: u128 = (u128::from(((((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8)) | (__v_46.as_canonical_u64() << 16)) | (__v_47.as_canonical_u64() << 24))) + u128::from(((((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8)) | (__v_326.as_canonical_u64() << 16)) | (__v_327.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_330: G = G::from_u8(__u32_bytes[0]); let __v_331: G = G::from_u8(__u32_bytes[1]); let __v_332: G = G::from_u8(__u32_bytes[2]); let __v_333: G = G::from_u8(__u32_bytes[3]); let __v_334: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_330; let __vj = __v_331; 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_332; let __vj = __v_333; 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_335: G = (__v_334 * __v_334); if (__v_335 != __v_334) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_334.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_330)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_330, record) }; let __v_336: G = __b2_out.0; let __v_337: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_338: G = __b2_out.0; let __v_339: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_340: G = __b2_out.0; let __v_341: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_342: G = __b2_out.0; let __v_343: G = __b2_out.1; let __v_344: G = (__v_338 + __v_341); let __v_345: G = (__v_340 + __v_343); let __v_346: G = (__v_342 + __v_337); let __v_347: G = (__v_336 + __v_339); let __u32_sum: u128 = ((u128::from(((((__v_317.as_canonical_u64() << 0) | (__v_318.as_canonical_u64() << 8)) | (__v_319.as_canonical_u64() << 16)) | (__v_320.as_canonical_u64() << 24))) + u128::from(((((__v_344.as_canonical_u64() << 0) | (__v_345.as_canonical_u64() << 8)) | (__v_346.as_canonical_u64() << 16)) | (__v_347.as_canonical_u64() << 24)))) + u128::from(((((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8)) | (__v_94.as_canonical_u64() << 16)) | (__v_95.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); let __v_349: G = G::from_u8(__u32_bytes[1]); let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_348; let __vj = __v_349; 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_350; let __vj = __v_351; 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_353: G = (__v_352 - __v_133); let __v_354: G = (__v_352 - __v_135); let __v_355: G = (__v_353 * __v_354); let __v_356: G = (__v_352 * __v_355); if (__v_356 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_357: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_348)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_348, record) }; let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_326), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_326, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __u32_sum: u128 = (u128::from(((((__v_330.as_canonical_u64() << 0) | (__v_331.as_canonical_u64() << 8)) | (__v_332.as_canonical_u64() << 16)) | (__v_333.as_canonical_u64() << 24))) + u128::from(((((__v_358.as_canonical_u64() << 0) | (__v_359.as_canonical_u64() << 8)) | (__v_360.as_canonical_u64() << 16)) | (__v_357.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_361: G = G::from_u8(__u32_bytes[0]); let __v_362: G = G::from_u8(__u32_bytes[1]); let __v_363: G = G::from_u8(__u32_bytes[2]); let __v_364: G = G::from_u8(__u32_bytes[3]); let __v_365: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_361; let __vj = __v_362; 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_363; let __vj = __v_364; 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_366: G = (__v_365 * __v_365); if (__v_366 != __v_365) { return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_365.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_344), (&__v_361)) } else { aiur::execute::bytes2_xor_split7_value(__v_344, __v_361, record) }; let __v_367: G = __b2_out.0; let __v_368: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_369: G = __b2_out.0; let __v_370: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_371: G = __b2_out.0; let __v_372: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_373: G = __b2_out.0; let __v_374: G = __b2_out.1; let __v_375: G = (__v_367 + __v_370); let __v_376: G = (__v_369 + __v_372); let __v_377: G = (__v_371 + __v_374); let __v_378: G = (__v_373 + __v_368); let __u32_sum: u128 = ((u128::from(((((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8)) | (__v_164.as_canonical_u64() << 16)) | (__v_165.as_canonical_u64() << 24))) + u128::from(((((__v_251.as_canonical_u64() << 0) | (__v_252.as_canonical_u64() << 8)) | (__v_253.as_canonical_u64() << 16)) | (__v_254.as_canonical_u64() << 24)))) + u128::from(((((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8)) | (__v_98.as_canonical_u64() << 16)) | (__v_99.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_379: G = G::from_u8(__u32_bytes[0]); let __v_380: G = G::from_u8(__u32_bytes[1]); let __v_381: G = G::from_u8(__u32_bytes[2]); let __v_382: G = G::from_u8(__u32_bytes[3]); let __v_383: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_379; let __vj = __v_380; 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_381; let __vj = __v_382; 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_384: G = (__v_383 - __v_133); let __v_385: G = (__v_383 - __v_135); let __v_386: G = (__v_384 * __v_385); let __v_387: G = (__v_383 * __v_386); if (__v_387 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_388: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_379)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_379, record) }; let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_357), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_357, __v_382, record) }; let __u32_sum: u128 = (u128::from(((((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8)) | (__v_301.as_canonical_u64() << 16)) | (__v_302.as_canonical_u64() << 24))) + u128::from(((((__v_390.as_canonical_u64() << 0) | (__v_391.as_canonical_u64() << 8)) | (__v_388.as_canonical_u64() << 16)) | (__v_389.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_392: G = G::from_u8(__u32_bytes[0]); let __v_393: G = G::from_u8(__u32_bytes[1]); let __v_394: G = G::from_u8(__u32_bytes[2]); let __v_395: G = G::from_u8(__u32_bytes[3]); let __v_396: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_392; let __vj = __v_393; 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_394; let __vj = __v_395; 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_397: G = (__v_396 * __v_396); if (__v_397 != __v_396) { return Err(ExecError::AssertEqMismatch { lhs: __v_397.as_canonical_u64(), rhs: __v_396.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_251), (&__v_392)) } else { aiur::execute::bytes2_xor_split4_value(__v_251, __v_392, record) }; let __v_398: G = __b2_out.0; let __v_399: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_400: G = __b2_out.0; let __v_401: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_402: G = __b2_out.0; let __v_403: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_404: G = __b2_out.0; let __v_405: G = __b2_out.1; let __v_406: G = (__v_400 + __v_403); let __v_407: G = (__v_402 + __v_405); let __v_408: G = (__v_404 + __v_399); let __v_409: G = (__v_398 + __v_401); let __u32_sum: u128 = ((u128::from(((((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8)) | (__v_381.as_canonical_u64() << 16)) | (__v_382.as_canonical_u64() << 24))) + u128::from(((((__v_406.as_canonical_u64() << 0) | (__v_407.as_canonical_u64() << 8)) | (__v_408.as_canonical_u64() << 16)) | (__v_409.as_canonical_u64() << 24)))) + u128::from(((((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8)) | (__v_102.as_canonical_u64() << 16)) | (__v_103.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_410: G = G::from_u8(__u32_bytes[0]); let __v_411: G = G::from_u8(__u32_bytes[1]); let __v_412: G = G::from_u8(__u32_bytes[2]); let __v_413: G = G::from_u8(__u32_bytes[3]); let __v_414: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_410; let __vj = __v_411; 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_412; let __vj = __v_413; 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_415: G = (__v_414 - __v_133); let __v_416: G = (__v_414 - __v_135); let __v_417: G = (__v_415 * __v_416); let __v_418: G = (__v_414 * __v_417); if (__v_418 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_418.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_419: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_410)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_410, record) }; let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_388), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_388, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __u32_sum: u128 = (u128::from(((((__v_392.as_canonical_u64() << 0) | (__v_393.as_canonical_u64() << 8)) | (__v_394.as_canonical_u64() << 16)) | (__v_395.as_canonical_u64() << 24))) + u128::from(((((__v_420.as_canonical_u64() << 0) | (__v_421.as_canonical_u64() << 8)) | (__v_422.as_canonical_u64() << 16)) | (__v_419.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_423: G = G::from_u8(__u32_bytes[0]); let __v_424: G = G::from_u8(__u32_bytes[1]); let __v_425: G = G::from_u8(__u32_bytes[2]); let __v_426: G = G::from_u8(__u32_bytes[3]); let __v_427: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_423; let __vj = __v_424; 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_425; let __vj = __v_426; 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_428: G = (__v_427 * __v_427); if (__v_428 != __v_427) { return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_427.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_406), (&__v_423)) } else { aiur::execute::bytes2_xor_split7_value(__v_406, __v_423, record) }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_431: G = __b2_out.0; let __v_432: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_433: G = __b2_out.0; let __v_434: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_435: G = __b2_out.0; let __v_436: G = __b2_out.1; let __v_437: G = (__v_429 + __v_432); let __v_438: G = (__v_431 + __v_434); let __v_439: G = (__v_433 + __v_436); let __v_440: G = (__v_435 + __v_430); let __u32_sum: u128 = ((u128::from(((((__v_224.as_canonical_u64() << 0) | (__v_225.as_canonical_u64() << 8)) | (__v_226.as_canonical_u64() << 16)) | (__v_227.as_canonical_u64() << 24))) + u128::from(((((__v_313.as_canonical_u64() << 0) | (__v_314.as_canonical_u64() << 8)) | (__v_315.as_canonical_u64() << 16)) | (__v_316.as_canonical_u64() << 24)))) + u128::from(((((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8)) | (__v_106.as_canonical_u64() << 16)) | (__v_107.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_441: G = G::from_u8(__u32_bytes[0]); let __v_442: G = G::from_u8(__u32_bytes[1]); let __v_443: G = G::from_u8(__u32_bytes[2]); let __v_444: G = G::from_u8(__u32_bytes[3]); let __v_445: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_441; let __vj = __v_442; 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_443; let __vj = __v_444; 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_446: G = (__v_445 - __v_133); let __v_447: G = (__v_445 - __v_135); let __v_448: G = (__v_446 * __v_447); let __v_449: G = (__v_445 * __v_448); if (__v_449 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_449.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_450: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_441)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_441, record) }; let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_171), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_171, __v_444, record) }; let __u32_sum: u128 = (u128::from(((((__v_361.as_canonical_u64() << 0) | (__v_362.as_canonical_u64() << 8)) | (__v_363.as_canonical_u64() << 16)) | (__v_364.as_canonical_u64() << 24))) + u128::from(((((__v_452.as_canonical_u64() << 0) | (__v_453.as_canonical_u64() << 8)) | (__v_450.as_canonical_u64() << 16)) | (__v_451.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_454: G = G::from_u8(__u32_bytes[0]); let __v_455: G = G::from_u8(__u32_bytes[1]); let __v_456: G = G::from_u8(__u32_bytes[2]); let __v_457: G = G::from_u8(__u32_bytes[3]); let __v_458: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_454; let __vj = __v_455; 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_456; let __vj = __v_457; 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_459: G = (__v_458 * __v_458); if (__v_459 != __v_458) { return Err(ExecError::AssertEqMismatch { lhs: __v_459.as_canonical_u64(), rhs: __v_458.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_313), (&__v_454)) } else { aiur::execute::bytes2_xor_split4_value(__v_313, __v_454, record) }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_464: G = __b2_out.0; let __v_465: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_466: G = __b2_out.0; let __v_467: G = __b2_out.1; let __v_468: G = (__v_462 + __v_465); let __v_469: G = (__v_464 + __v_467); let __v_470: G = (__v_466 + __v_461); let __v_471: G = (__v_460 + __v_463); let __u32_sum: u128 = ((u128::from(((((__v_441.as_canonical_u64() << 0) | (__v_442.as_canonical_u64() << 8)) | (__v_443.as_canonical_u64() << 16)) | (__v_444.as_canonical_u64() << 24))) + u128::from(((((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8)) | (__v_470.as_canonical_u64() << 16)) | (__v_471.as_canonical_u64() << 24)))) + u128::from(((((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8)) | (__v_110.as_canonical_u64() << 16)) | (__v_111.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_472: G = G::from_u8(__u32_bytes[0]); let __v_473: G = G::from_u8(__u32_bytes[1]); let __v_474: G = G::from_u8(__u32_bytes[2]); let __v_475: G = G::from_u8(__u32_bytes[3]); let __v_476: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_472; let __vj = __v_473; 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_474; let __vj = __v_475; 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_477: G = (__v_476 - __v_133); let __v_478: G = (__v_476 - __v_135); let __v_479: G = (__v_477 * __v_478); let __v_480: G = (__v_476 * __v_479); if (__v_480 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_481: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_472)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_472, record) }; let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_450), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_450, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __u32_sum: u128 = (u128::from(((((__v_454.as_canonical_u64() << 0) | (__v_455.as_canonical_u64() << 8)) | (__v_456.as_canonical_u64() << 16)) | (__v_457.as_canonical_u64() << 24))) + u128::from(((((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8)) | (__v_484.as_canonical_u64() << 16)) | (__v_481.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); let __v_486: G = G::from_u8(__u32_bytes[1]); let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_485; let __vj = __v_486; 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_487; let __vj = __v_488; 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_490: G = (__v_489 * __v_489); if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_468), (&__v_485)) } else { aiur::execute::bytes2_xor_split7_value(__v_468, __v_485, record) }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = (__v_491 + __v_494); let __v_500: G = (__v_493 + __v_496); let __v_501: G = (__v_495 + __v_498); let __v_502: G = (__v_497 + __v_492); let __u32_sum: u128 = ((u128::from(((((__v_286.as_canonical_u64() << 0) | (__v_287.as_canonical_u64() << 8)) | (__v_288.as_canonical_u64() << 16)) | (__v_289.as_canonical_u64() << 24))) + u128::from(((((__v_375.as_canonical_u64() << 0) | (__v_376.as_canonical_u64() << 8)) | (__v_377.as_canonical_u64() << 16)) | (__v_378.as_canonical_u64() << 24)))) + u128::from(((((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8)) | (__v_114.as_canonical_u64() << 16)) | (__v_115.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_503: G = G::from_u8(__u32_bytes[0]); let __v_504: G = G::from_u8(__u32_bytes[1]); let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_503; let __vj = __v_504; 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_505; let __vj = __v_506; 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_508: G = (__v_507 - __v_133); let __v_509: G = (__v_507 - __v_135); let __v_510: G = (__v_508 * __v_509); let __v_511: G = (__v_507 * __v_510); if (__v_511 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_512: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_503)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_503, record) }; let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_233), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_233, __v_506, record) }; let __u32_sum: u128 = (u128::from(((((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8)) | (__v_177.as_canonical_u64() << 16)) | (__v_178.as_canonical_u64() << 24))) + u128::from(((((__v_514.as_canonical_u64() << 0) | (__v_515.as_canonical_u64() << 8)) | (__v_512.as_canonical_u64() << 16)) | (__v_513.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_516: G = G::from_u8(__u32_bytes[0]); let __v_517: G = G::from_u8(__u32_bytes[1]); let __v_518: G = G::from_u8(__u32_bytes[2]); let __v_519: G = G::from_u8(__u32_bytes[3]); let __v_520: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_516; let __vj = __v_517; 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_518; let __vj = __v_519; 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_521: G = (__v_520 * __v_520); if (__v_521 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_375), (&__v_516)) } else { aiur::execute::bytes2_xor_split4_value(__v_375, __v_516, record) }; let __v_522: G = __b2_out.0; let __v_523: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; let __v_530: G = (__v_524 + __v_527); let __v_531: G = (__v_526 + __v_529); let __v_532: G = (__v_528 + __v_523); let __v_533: G = (__v_522 + __v_525); let __u32_sum: u128 = ((u128::from(((((__v_503.as_canonical_u64() << 0) | (__v_504.as_canonical_u64() << 8)) | (__v_505.as_canonical_u64() << 16)) | (__v_506.as_canonical_u64() << 24))) + u128::from(((((__v_530.as_canonical_u64() << 0) | (__v_531.as_canonical_u64() << 8)) | (__v_532.as_canonical_u64() << 16)) | (__v_533.as_canonical_u64() << 24)))) + u128::from(((((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8)) | (__v_118.as_canonical_u64() << 16)) | (__v_119.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_534: G = G::from_u8(__u32_bytes[0]); let __v_535: G = G::from_u8(__u32_bytes[1]); let __v_536: G = G::from_u8(__u32_bytes[2]); let __v_537: G = G::from_u8(__u32_bytes[3]); let __v_538: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_534; let __vj = __v_535; 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_536; let __vj = __v_537; 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_539: G = (__v_538 - __v_133); let __v_540: G = (__v_538 - __v_135); let __v_541: G = (__v_539 * __v_540); let __v_542: G = (__v_538 * __v_541); if (__v_542 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_542.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_543: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_534)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_534, record) }; let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_512), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_512, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __u32_sum: u128 = (u128::from(((((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8)) | (__v_518.as_canonical_u64() << 16)) | (__v_519.as_canonical_u64() << 24))) + u128::from(((((__v_544.as_canonical_u64() << 0) | (__v_545.as_canonical_u64() << 8)) | (__v_546.as_canonical_u64() << 16)) | (__v_543.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_547: G = G::from_u8(__u32_bytes[0]); let __v_548: G = G::from_u8(__u32_bytes[1]); let __v_549: G = G::from_u8(__u32_bytes[2]); let __v_550: G = G::from_u8(__u32_bytes[3]); let __v_551: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_547; let __vj = __v_548; 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_549; let __vj = __v_550; 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_552: G = (__v_551 * __v_551); if (__v_552 != __v_551) { return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_551.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_530), (&__v_547)) } else { aiur::execute::bytes2_xor_split7_value(__v_530, __v_547, record) }; let __v_553: G = __b2_out.0; let __v_554: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_555: G = __b2_out.0; let __v_556: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_557: G = __b2_out.0; let __v_558: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; let __v_561: G = (__v_553 + __v_556); let __v_562: G = (__v_555 + __v_558); let __v_563: G = (__v_557 + __v_560); let __v_564: G = (__v_559 + __v_554); let __u32_sum: u128 = ((u128::from(((((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8)) | (__v_350.as_canonical_u64() << 16)) | (__v_351.as_canonical_u64() << 24))) + u128::from(((((__v_189.as_canonical_u64() << 0) | (__v_190.as_canonical_u64() << 8)) | (__v_191.as_canonical_u64() << 16)) | (__v_192.as_canonical_u64() << 24)))) + u128::from(((((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8)) | (__v_122.as_canonical_u64() << 16)) | (__v_123.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_565: G = G::from_u8(__u32_bytes[0]); let __v_566: G = G::from_u8(__u32_bytes[1]); let __v_567: G = G::from_u8(__u32_bytes[2]); let __v_568: G = G::from_u8(__u32_bytes[3]); let __v_569: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_565; let __vj = __v_566; 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_567; let __vj = __v_568; 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_570: G = (__v_569 - __v_133); let __v_571: G = (__v_569 - __v_135); let __v_572: G = (__v_570 * __v_571); let __v_573: G = (__v_569 * __v_572); if (__v_573 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_574: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_565)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_565, record) }; let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_295), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_295, __v_568, record) }; let __u32_sum: u128 = (u128::from(((((__v_237.as_canonical_u64() << 0) | (__v_238.as_canonical_u64() << 8)) | (__v_239.as_canonical_u64() << 16)) | (__v_240.as_canonical_u64() << 24))) + u128::from(((((__v_576.as_canonical_u64() << 0) | (__v_577.as_canonical_u64() << 8)) | (__v_574.as_canonical_u64() << 16)) | (__v_575.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_578: G = G::from_u8(__u32_bytes[0]); let __v_579: G = G::from_u8(__u32_bytes[1]); let __v_580: G = G::from_u8(__u32_bytes[2]); let __v_581: G = G::from_u8(__u32_bytes[3]); let __v_582: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_578; let __vj = __v_579; 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_580; let __vj = __v_581; 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_583: G = (__v_582 * __v_582); if (__v_583 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_583.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_189), (&__v_578)) } else { aiur::execute::bytes2_xor_split4_value(__v_189, __v_578, record) }; let __v_584: G = __b2_out.0; let __v_585: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_586: G = __b2_out.0; let __v_587: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_588: G = __b2_out.0; let __v_589: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_590: G = __b2_out.0; let __v_591: G = __b2_out.1; let __v_592: G = (__v_586 + __v_589); let __v_593: G = (__v_588 + __v_591); let __v_594: G = (__v_590 + __v_585); let __v_595: G = (__v_584 + __v_587); let __u32_sum: u128 = ((u128::from(((((__v_565.as_canonical_u64() << 0) | (__v_566.as_canonical_u64() << 8)) | (__v_567.as_canonical_u64() << 16)) | (__v_568.as_canonical_u64() << 24))) + u128::from(((((__v_592.as_canonical_u64() << 0) | (__v_593.as_canonical_u64() << 8)) | (__v_594.as_canonical_u64() << 16)) | (__v_595.as_canonical_u64() << 24)))) + u128::from(((((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8)) | (__v_126.as_canonical_u64() << 16)) | (__v_127.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_596: G = G::from_u8(__u32_bytes[0]); let __v_597: G = G::from_u8(__u32_bytes[1]); let __v_598: G = G::from_u8(__u32_bytes[2]); let __v_599: G = G::from_u8(__u32_bytes[3]); let __v_600: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_596; let __vj = __v_597; 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_598; let __vj = __v_599; 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_601: G = (__v_600 - __v_133); let __v_602: G = (__v_600 - __v_135); let __v_603: G = (__v_601 * __v_602); let __v_604: G = (__v_600 * __v_603); if (__v_604 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_604.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_605: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_596)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_596, record) }; let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_574), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_574, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __u32_sum: u128 = (u128::from(((((__v_578.as_canonical_u64() << 0) | (__v_579.as_canonical_u64() << 8)) | (__v_580.as_canonical_u64() << 16)) | (__v_581.as_canonical_u64() << 24))) + u128::from(((((__v_606.as_canonical_u64() << 0) | (__v_607.as_canonical_u64() << 8)) | (__v_608.as_canonical_u64() << 16)) | (__v_605.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_609: G = G::from_u8(__u32_bytes[0]); let __v_610: G = G::from_u8(__u32_bytes[1]); let __v_611: G = G::from_u8(__u32_bytes[2]); let __v_612: G = G::from_u8(__u32_bytes[3]); let __v_613: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_609; let __vj = __v_610; 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_611; let __vj = __v_612; 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_614: G = (__v_613 * __v_613); if (__v_614 != __v_613) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_613.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_592), (&__v_609)) } else { aiur::execute::bytes2_xor_split7_value(__v_592, __v_609, record) }; let __v_615: G = __b2_out.0; let __v_616: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_617: G = __b2_out.0; let __v_618: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_619: G = __b2_out.0; let __v_620: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_621: G = __b2_out.0; let __v_622: G = __b2_out.1; let __v_623: G = (__v_615 + __v_618); let __v_624: G = (__v_617 + __v_620); let __v_625: G = (__v_619 + __v_622); let __v_626: G = (__v_621 + __v_616); let __ret: [G; OUT_81] = [__v_410, __v_411, __v_412, __v_413, __v_472, __v_473, __v_474, __v_475, __v_534, __v_535, __v_536, __v_537, __v_596, __v_597, __v_598, __v_599, __v_623, __v_624, __v_625, __v_626, __v_437, __v_438, __v_439, __v_440, __v_499, __v_500, __v_501, __v_502, __v_561, __v_562, __v_563, __v_564, __v_547, __v_548, __v_549, __v_550, __v_609, __v_610, __v_611, __v_612, __v_423, __v_424, __v_425, __v_426, __v_485, __v_486, __v_487, __v_488, __v_482, __v_483, __v_484, __v_481, __v_544, __v_545, __v_546, __v_543, __v_606, __v_607, __v_608, __v_605, __v_420, __v_421, __v_422, __v_419, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_81(inp: [G; IN_81], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __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_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24))) + u128::from((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; 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_130; let __vj = __v_131; 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_133: G = G::from_u64(1); let __v_134: G = __v_132 - __v_133; let __v_135: G = G::from_u64(2); let __v_136: G = __v_132 - __v_135; let __v_137: G = __v_134 * __v_136; let __v_138: G = __v_132 * __v_137; let __v_139: G = G::from_u64(0); if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_48, &__v_128) } else { aiur::execute::bytes2_xor_value(__v_48, __v_128, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_49, &__v_129) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_50, &__v_130) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_51, &__v_131) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __u32_sum: u128 = u128::from((((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8)) | (__v_34.as_canonical_u64() << 16)) | (__v_35.as_canonical_u64() << 24)) + u128::from((((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8)) | (__v_140.as_canonical_u64() << 16)) | (__v_141.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); let __v_145: G = G::from_u8(__u32_bytes[1]); let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; 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_146; let __vj = __v_147; 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_149: G = __v_148 * __v_148; if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_16, &__v_144) } else { aiur::execute::bytes2_xor_split4_value(__v_16, __v_144, record) }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_17, &__v_145) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_18, &__v_146) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_19, &__v_147) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = __v_152 + __v_155; let __v_159: G = __v_154 + __v_157; let __v_160: G = __v_156 + __v_151; let __v_161: G = __v_150 + __v_153; let __u32_sum: u128 = (u128::from((((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8)) | (__v_130.as_canonical_u64() << 16)) | (__v_131.as_canonical_u64() << 24)) + u128::from((((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8)) | (__v_160.as_canonical_u64() << 16)) | (__v_161.as_canonical_u64() << 24))) + u128::from((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_71.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_162: G = G::from_u8(__u32_bytes[0]); let __v_163: G = G::from_u8(__u32_bytes[1]); let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_162; let __vj = __v_163; 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_164; let __vj = __v_165; 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_167: G = __v_166 - __v_133; let __v_168: G = __v_166 - __v_135; let __v_169: G = __v_167 * __v_168; let __v_170: G = __v_166 * __v_169; if (__v_170 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_171: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_142, &__v_162) } else { aiur::execute::bytes2_xor_value(__v_142, __v_162, record) }; let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_143, &__v_163) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_140, &__v_164) } else { aiur::execute::bytes2_xor_value(__v_140, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_141, &__v_165) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __u32_sum: u128 = u128::from((((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8)) | (__v_146.as_canonical_u64() << 16)) | (__v_147.as_canonical_u64() << 24)) + u128::from((((__v_172.as_canonical_u64() << 0) | (__v_173.as_canonical_u64() << 8)) | (__v_174.as_canonical_u64() << 16)) | (__v_171.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_175: G = G::from_u8(__u32_bytes[0]); let __v_176: G = G::from_u8(__u32_bytes[1]); let __v_177: G = G::from_u8(__u32_bytes[2]); let __v_178: G = G::from_u8(__u32_bytes[3]); let __v_179: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_175; let __vj = __v_176; 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_177; let __vj = __v_178; 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_180: G = __v_179 * __v_179; if (__v_180 != __v_179) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_179.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_158, &__v_175) } else { aiur::execute::bytes2_xor_split7_value(__v_158, __v_175, record) }; let __v_181: G = __b2_out.0; let __v_182: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_159, &__v_176) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_183: G = __b2_out.0; let __v_184: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_160, &__v_177) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_161, &__v_178) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; let __v_189: G = __v_181 + __v_184; let __v_190: G = __v_183 + __v_186; let __v_191: G = __v_185 + __v_188; let __v_192: G = __v_187 + __v_182; let __u32_sum: u128 = (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_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24))) + u128::from((((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8)) | (__v_74.as_canonical_u64() << 16)) | (__v_75.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_193: G = G::from_u8(__u32_bytes[0]); let __v_194: G = G::from_u8(__u32_bytes[1]); let __v_195: G = G::from_u8(__u32_bytes[2]); let __v_196: G = G::from_u8(__u32_bytes[3]); let __v_197: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_193; let __vj = __v_194; 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_195; let __vj = __v_196; 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_198: G = __v_197 - __v_133; let __v_199: G = __v_197 - __v_135; let __v_200: G = __v_198 * __v_199; let __v_201: G = __v_197 * __v_200; if (__v_201 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_202: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_52, &__v_193) } else { aiur::execute::bytes2_xor_value(__v_52, __v_193, record) }; let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_53, &__v_194) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_54, &__v_195) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_55, &__v_196) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __u32_sum: u128 = u128::from((((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8)) | (__v_38.as_canonical_u64() << 16)) | (__v_39.as_canonical_u64() << 24)) + u128::from((((__v_204.as_canonical_u64() << 0) | (__v_205.as_canonical_u64() << 8)) | (__v_202.as_canonical_u64() << 16)) | (__v_203.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_206: G = G::from_u8(__u32_bytes[0]); let __v_207: G = G::from_u8(__u32_bytes[1]); let __v_208: G = G::from_u8(__u32_bytes[2]); let __v_209: G = G::from_u8(__u32_bytes[3]); let __v_210: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_206; let __vj = __v_207; 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_208; let __vj = __v_209; 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_211: G = __v_210 * __v_210; if (__v_211 != __v_210) { return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_210.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_20, &__v_206) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_206, record) }; let __v_212: G = __b2_out.0; let __v_213: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_21, &__v_207) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_214: G = __b2_out.0; let __v_215: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_22, &__v_208) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_216: G = __b2_out.0; let __v_217: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_23, &__v_209) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; let __v_220: G = __v_214 + __v_217; let __v_221: G = __v_216 + __v_219; let __v_222: G = __v_218 + __v_213; let __v_223: G = __v_212 + __v_215; let __u32_sum: u128 = (u128::from((((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8)) | (__v_195.as_canonical_u64() << 16)) | (__v_196.as_canonical_u64() << 24)) + u128::from((((__v_220.as_canonical_u64() << 0) | (__v_221.as_canonical_u64() << 8)) | (__v_222.as_canonical_u64() << 16)) | (__v_223.as_canonical_u64() << 24))) + u128::from((((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8)) | (__v_78.as_canonical_u64() << 16)) | (__v_79.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_224: G = G::from_u8(__u32_bytes[0]); let __v_225: G = G::from_u8(__u32_bytes[1]); let __v_226: G = G::from_u8(__u32_bytes[2]); let __v_227: G = G::from_u8(__u32_bytes[3]); let __v_228: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_224; let __vj = __v_225; 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_226; let __vj = __v_227; 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_229: G = __v_228 - __v_133; let __v_230: G = __v_228 - __v_135; let __v_231: G = __v_229 * __v_230; let __v_232: G = __v_228 * __v_231; if (__v_232 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_233: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_204, &__v_224) } else { aiur::execute::bytes2_xor_value(__v_204, __v_224, record) }; let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_205, &__v_225) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_202, &__v_226) } else { aiur::execute::bytes2_xor_value(__v_202, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_203, &__v_227) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __u32_sum: u128 = u128::from((((__v_206.as_canonical_u64() << 0) | (__v_207.as_canonical_u64() << 8)) | (__v_208.as_canonical_u64() << 16)) | (__v_209.as_canonical_u64() << 24)) + u128::from((((__v_234.as_canonical_u64() << 0) | (__v_235.as_canonical_u64() << 8)) | (__v_236.as_canonical_u64() << 16)) | (__v_233.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_237: G = G::from_u8(__u32_bytes[0]); let __v_238: G = G::from_u8(__u32_bytes[1]); let __v_239: G = G::from_u8(__u32_bytes[2]); let __v_240: G = G::from_u8(__u32_bytes[3]); let __v_241: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; 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_239; let __vj = __v_240; 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_242: G = __v_241 * __v_241; if (__v_242 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_220, &__v_237) } else { aiur::execute::bytes2_xor_split7_value(__v_220, __v_237, record) }; let __v_243: G = __b2_out.0; let __v_244: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_221, &__v_238) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_245: G = __b2_out.0; let __v_246: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_222, &__v_239) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_247: G = __b2_out.0; let __v_248: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_223, &__v_240) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_249: G = __b2_out.0; let __v_250: G = __b2_out.1; let __v_251: G = __v_243 + __v_246; let __v_252: G = __v_245 + __v_248; let __v_253: G = __v_247 + __v_250; let __v_254: G = __v_249 + __v_244; let __u32_sum: u128 = (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)) + u128::from((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24))) + u128::from((((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8)) | (__v_82.as_canonical_u64() << 16)) | (__v_83.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_255: G = G::from_u8(__u32_bytes[0]); let __v_256: G = G::from_u8(__u32_bytes[1]); let __v_257: G = G::from_u8(__u32_bytes[2]); let __v_258: G = G::from_u8(__u32_bytes[3]); let __v_259: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_255; let __vj = __v_256; 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_257; let __vj = __v_258; 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_260: G = __v_259 - __v_133; let __v_261: G = __v_259 - __v_135; let __v_262: G = __v_260 * __v_261; let __v_263: G = __v_259 * __v_262; if (__v_263 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_263.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_264: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_56, &__v_255) } else { aiur::execute::bytes2_xor_value(__v_56, __v_255, record) }; let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_57, &__v_256) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_58, &__v_257) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_59, &__v_258) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __u32_sum: u128 = u128::from((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24)) + u128::from((((__v_266.as_canonical_u64() << 0) | (__v_267.as_canonical_u64() << 8)) | (__v_264.as_canonical_u64() << 16)) | (__v_265.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_268: G = G::from_u8(__u32_bytes[0]); let __v_269: G = G::from_u8(__u32_bytes[1]); let __v_270: G = G::from_u8(__u32_bytes[2]); let __v_271: G = G::from_u8(__u32_bytes[3]); let __v_272: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; 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_270; let __vj = __v_271; 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_273: G = __v_272 * __v_272; if (__v_273 != __v_272) { return Err(ExecError::AssertEqMismatch { lhs: __v_273.as_canonical_u64(), rhs: __v_272.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_24, &__v_268) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_268, record) }; let __v_274: G = __b2_out.0; let __v_275: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_25, &__v_269) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_276: G = __b2_out.0; let __v_277: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_26, &__v_270) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_278: G = __b2_out.0; let __v_279: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_27, &__v_271) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_280: G = __b2_out.0; let __v_281: G = __b2_out.1; let __v_282: G = __v_276 + __v_279; let __v_283: G = __v_278 + __v_281; let __v_284: G = __v_280 + __v_275; let __v_285: G = __v_274 + __v_277; let __u32_sum: u128 = (u128::from((((__v_255.as_canonical_u64() << 0) | (__v_256.as_canonical_u64() << 8)) | (__v_257.as_canonical_u64() << 16)) | (__v_258.as_canonical_u64() << 24)) + u128::from((((__v_282.as_canonical_u64() << 0) | (__v_283.as_canonical_u64() << 8)) | (__v_284.as_canonical_u64() << 16)) | (__v_285.as_canonical_u64() << 24))) + u128::from((((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8)) | (__v_86.as_canonical_u64() << 16)) | (__v_87.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_286: G = G::from_u8(__u32_bytes[0]); let __v_287: G = G::from_u8(__u32_bytes[1]); let __v_288: G = G::from_u8(__u32_bytes[2]); let __v_289: G = G::from_u8(__u32_bytes[3]); let __v_290: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_286; let __vj = __v_287; 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_288; let __vj = __v_289; 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_291: G = __v_290 - __v_133; let __v_292: G = __v_290 - __v_135; let __v_293: G = __v_291 * __v_292; let __v_294: G = __v_290 * __v_293; if (__v_294 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_294.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_295: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_266, &__v_286) } else { aiur::execute::bytes2_xor_value(__v_266, __v_286, record) }; let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_267, &__v_287) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_264, &__v_288) } else { aiur::execute::bytes2_xor_value(__v_264, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_265, &__v_289) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __u32_sum: u128 = u128::from((((__v_268.as_canonical_u64() << 0) | (__v_269.as_canonical_u64() << 8)) | (__v_270.as_canonical_u64() << 16)) | (__v_271.as_canonical_u64() << 24)) + u128::from((((__v_296.as_canonical_u64() << 0) | (__v_297.as_canonical_u64() << 8)) | (__v_298.as_canonical_u64() << 16)) | (__v_295.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_299: G = G::from_u8(__u32_bytes[0]); let __v_300: G = G::from_u8(__u32_bytes[1]); let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_299; let __vj = __v_300; 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_301; let __vj = __v_302; 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_304: G = __v_303 * __v_303; if (__v_304 != __v_303) { return Err(ExecError::AssertEqMismatch { lhs: __v_304.as_canonical_u64(), rhs: __v_303.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_282, &__v_299) } else { aiur::execute::bytes2_xor_split7_value(__v_282, __v_299, record) }; let __v_305: G = __b2_out.0; let __v_306: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_283, &__v_300) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_307: G = __b2_out.0; let __v_308: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_284, &__v_301) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_309: G = __b2_out.0; let __v_310: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_285, &__v_302) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_311: G = __b2_out.0; let __v_312: G = __b2_out.1; let __v_313: G = __v_305 + __v_308; let __v_314: G = __v_307 + __v_310; let __v_315: G = __v_309 + __v_312; let __v_316: G = __v_311 + __v_306; let __u32_sum: u128 = (u128::from((((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8)) | (__v_14.as_canonical_u64() << 16)) | (__v_15.as_canonical_u64() << 24)) + u128::from((((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8)) | (__v_30.as_canonical_u64() << 16)) | (__v_31.as_canonical_u64() << 24))) + u128::from((((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8)) | (__v_90.as_canonical_u64() << 16)) | (__v_91.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_317: G = G::from_u8(__u32_bytes[0]); let __v_318: G = G::from_u8(__u32_bytes[1]); let __v_319: G = G::from_u8(__u32_bytes[2]); let __v_320: G = G::from_u8(__u32_bytes[3]); let __v_321: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_317; let __vj = __v_318; 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_319; let __vj = __v_320; 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_322: G = __v_321 - __v_133; let __v_323: G = __v_321 - __v_135; let __v_324: G = __v_322 * __v_323; let __v_325: G = __v_321 * __v_324; if (__v_325 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_325.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_326: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_60, &__v_317) } else { aiur::execute::bytes2_xor_value(__v_60, __v_317, record) }; let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_61, &__v_318) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_62, &__v_319) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_63, &__v_320) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __u32_sum: u128 = u128::from((((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8)) | (__v_46.as_canonical_u64() << 16)) | (__v_47.as_canonical_u64() << 24)) + u128::from((((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8)) | (__v_326.as_canonical_u64() << 16)) | (__v_327.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_330: G = G::from_u8(__u32_bytes[0]); let __v_331: G = G::from_u8(__u32_bytes[1]); let __v_332: G = G::from_u8(__u32_bytes[2]); let __v_333: G = G::from_u8(__u32_bytes[3]); let __v_334: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_330; let __vj = __v_331; 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_332; let __vj = __v_333; 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_335: G = __v_334 * __v_334; if (__v_335 != __v_334) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_334.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_28, &__v_330) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_330, record) }; let __v_336: G = __b2_out.0; let __v_337: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_29, &__v_331) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_338: G = __b2_out.0; let __v_339: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_30, &__v_332) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_340: G = __b2_out.0; let __v_341: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_31, &__v_333) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_342: G = __b2_out.0; let __v_343: G = __b2_out.1; let __v_344: G = __v_338 + __v_341; let __v_345: G = __v_340 + __v_343; let __v_346: G = __v_342 + __v_337; let __v_347: G = __v_336 + __v_339; let __u32_sum: u128 = (u128::from((((__v_317.as_canonical_u64() << 0) | (__v_318.as_canonical_u64() << 8)) | (__v_319.as_canonical_u64() << 16)) | (__v_320.as_canonical_u64() << 24)) + u128::from((((__v_344.as_canonical_u64() << 0) | (__v_345.as_canonical_u64() << 8)) | (__v_346.as_canonical_u64() << 16)) | (__v_347.as_canonical_u64() << 24))) + u128::from((((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8)) | (__v_94.as_canonical_u64() << 16)) | (__v_95.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); let __v_349: G = G::from_u8(__u32_bytes[1]); let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_348; let __vj = __v_349; 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_350; let __vj = __v_351; 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_353: G = __v_352 - __v_133; let __v_354: G = __v_352 - __v_135; let __v_355: G = __v_353 * __v_354; let __v_356: G = __v_352 * __v_355; if (__v_356 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_357: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_328, &__v_348) } else { aiur::execute::bytes2_xor_value(__v_328, __v_348, record) }; let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_329, &__v_349) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_326, &__v_350) } else { aiur::execute::bytes2_xor_value(__v_326, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_327, &__v_351) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __u32_sum: u128 = u128::from((((__v_330.as_canonical_u64() << 0) | (__v_331.as_canonical_u64() << 8)) | (__v_332.as_canonical_u64() << 16)) | (__v_333.as_canonical_u64() << 24)) + u128::from((((__v_358.as_canonical_u64() << 0) | (__v_359.as_canonical_u64() << 8)) | (__v_360.as_canonical_u64() << 16)) | (__v_357.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_361: G = G::from_u8(__u32_bytes[0]); let __v_362: G = G::from_u8(__u32_bytes[1]); let __v_363: G = G::from_u8(__u32_bytes[2]); let __v_364: G = G::from_u8(__u32_bytes[3]); let __v_365: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_361; let __vj = __v_362; 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_363; let __vj = __v_364; 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_366: G = __v_365 * __v_365; if (__v_366 != __v_365) { return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_365.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_344, &__v_361) } else { aiur::execute::bytes2_xor_split7_value(__v_344, __v_361, record) }; let __v_367: G = __b2_out.0; let __v_368: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_345, &__v_362) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_369: G = __b2_out.0; let __v_370: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_346, &__v_363) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_371: G = __b2_out.0; let __v_372: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_347, &__v_364) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_373: G = __b2_out.0; let __v_374: G = __b2_out.1; let __v_375: G = __v_367 + __v_370; let __v_376: G = __v_369 + __v_372; let __v_377: G = __v_371 + __v_374; let __v_378: G = __v_373 + __v_368; let __u32_sum: u128 = (u128::from((((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8)) | (__v_164.as_canonical_u64() << 16)) | (__v_165.as_canonical_u64() << 24)) + u128::from((((__v_251.as_canonical_u64() << 0) | (__v_252.as_canonical_u64() << 8)) | (__v_253.as_canonical_u64() << 16)) | (__v_254.as_canonical_u64() << 24))) + u128::from((((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8)) | (__v_98.as_canonical_u64() << 16)) | (__v_99.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_379: G = G::from_u8(__u32_bytes[0]); let __v_380: G = G::from_u8(__u32_bytes[1]); let __v_381: G = G::from_u8(__u32_bytes[2]); let __v_382: G = G::from_u8(__u32_bytes[3]); let __v_383: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_379; let __vj = __v_380; 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_381; let __vj = __v_382; 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_384: G = __v_383 - __v_133; let __v_385: G = __v_383 - __v_135; let __v_386: G = __v_384 * __v_385; let __v_387: G = __v_383 * __v_386; if (__v_387 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_388: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_358, &__v_379) } else { aiur::execute::bytes2_xor_value(__v_358, __v_379, record) }; let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_359, &__v_380) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_360, &__v_381) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_357, &__v_382) } else { aiur::execute::bytes2_xor_value(__v_357, __v_382, record) }; let __u32_sum: u128 = u128::from((((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8)) | (__v_301.as_canonical_u64() << 16)) | (__v_302.as_canonical_u64() << 24)) + u128::from((((__v_390.as_canonical_u64() << 0) | (__v_391.as_canonical_u64() << 8)) | (__v_388.as_canonical_u64() << 16)) | (__v_389.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_392: G = G::from_u8(__u32_bytes[0]); let __v_393: G = G::from_u8(__u32_bytes[1]); let __v_394: G = G::from_u8(__u32_bytes[2]); let __v_395: G = G::from_u8(__u32_bytes[3]); let __v_396: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_392; let __vj = __v_393; 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_394; let __vj = __v_395; 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_397: G = __v_396 * __v_396; if (__v_397 != __v_396) { return Err(ExecError::AssertEqMismatch { lhs: __v_397.as_canonical_u64(), rhs: __v_396.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_251, &__v_392) } else { aiur::execute::bytes2_xor_split4_value(__v_251, __v_392, record) }; let __v_398: G = __b2_out.0; let __v_399: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_252, &__v_393) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_400: G = __b2_out.0; let __v_401: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_253, &__v_394) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_402: G = __b2_out.0; let __v_403: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_254, &__v_395) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_404: G = __b2_out.0; let __v_405: G = __b2_out.1; let __v_406: G = __v_400 + __v_403; let __v_407: G = __v_402 + __v_405; let __v_408: G = __v_404 + __v_399; let __v_409: G = __v_398 + __v_401; let __u32_sum: u128 = (u128::from((((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8)) | (__v_381.as_canonical_u64() << 16)) | (__v_382.as_canonical_u64() << 24)) + u128::from((((__v_406.as_canonical_u64() << 0) | (__v_407.as_canonical_u64() << 8)) | (__v_408.as_canonical_u64() << 16)) | (__v_409.as_canonical_u64() << 24))) + u128::from((((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8)) | (__v_102.as_canonical_u64() << 16)) | (__v_103.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_410: G = G::from_u8(__u32_bytes[0]); let __v_411: G = G::from_u8(__u32_bytes[1]); let __v_412: G = G::from_u8(__u32_bytes[2]); let __v_413: G = G::from_u8(__u32_bytes[3]); let __v_414: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_410; let __vj = __v_411; 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_412; let __vj = __v_413; 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_415: G = __v_414 - __v_133; let __v_416: G = __v_414 - __v_135; let __v_417: G = __v_415 * __v_416; let __v_418: G = __v_414 * __v_417; if (__v_418 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_418.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_419: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_390, &__v_410) } else { aiur::execute::bytes2_xor_value(__v_390, __v_410, record) }; let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_391, &__v_411) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_388, &__v_412) } else { aiur::execute::bytes2_xor_value(__v_388, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_389, &__v_413) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __u32_sum: u128 = u128::from((((__v_392.as_canonical_u64() << 0) | (__v_393.as_canonical_u64() << 8)) | (__v_394.as_canonical_u64() << 16)) | (__v_395.as_canonical_u64() << 24)) + u128::from((((__v_420.as_canonical_u64() << 0) | (__v_421.as_canonical_u64() << 8)) | (__v_422.as_canonical_u64() << 16)) | (__v_419.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_423: G = G::from_u8(__u32_bytes[0]); let __v_424: G = G::from_u8(__u32_bytes[1]); let __v_425: G = G::from_u8(__u32_bytes[2]); let __v_426: G = G::from_u8(__u32_bytes[3]); let __v_427: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_423; let __vj = __v_424; 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_425; let __vj = __v_426; 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_428: G = __v_427 * __v_427; if (__v_428 != __v_427) { return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_427.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_406, &__v_423) } else { aiur::execute::bytes2_xor_split7_value(__v_406, __v_423, record) }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_407, &__v_424) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_431: G = __b2_out.0; let __v_432: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_408, &__v_425) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_433: G = __b2_out.0; let __v_434: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_409, &__v_426) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_435: G = __b2_out.0; let __v_436: G = __b2_out.1; let __v_437: G = __v_429 + __v_432; let __v_438: G = __v_431 + __v_434; let __v_439: G = __v_433 + __v_436; let __v_440: G = __v_435 + __v_430; let __u32_sum: u128 = (u128::from((((__v_224.as_canonical_u64() << 0) | (__v_225.as_canonical_u64() << 8)) | (__v_226.as_canonical_u64() << 16)) | (__v_227.as_canonical_u64() << 24)) + u128::from((((__v_313.as_canonical_u64() << 0) | (__v_314.as_canonical_u64() << 8)) | (__v_315.as_canonical_u64() << 16)) | (__v_316.as_canonical_u64() << 24))) + u128::from((((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8)) | (__v_106.as_canonical_u64() << 16)) | (__v_107.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_441: G = G::from_u8(__u32_bytes[0]); let __v_442: G = G::from_u8(__u32_bytes[1]); let __v_443: G = G::from_u8(__u32_bytes[2]); let __v_444: G = G::from_u8(__u32_bytes[3]); let __v_445: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_441; let __vj = __v_442; 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_443; let __vj = __v_444; 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_446: G = __v_445 - __v_133; let __v_447: G = __v_445 - __v_135; let __v_448: G = __v_446 * __v_447; let __v_449: G = __v_445 * __v_448; if (__v_449 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_449.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_450: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_172, &__v_441) } else { aiur::execute::bytes2_xor_value(__v_172, __v_441, record) }; let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_173, &__v_442) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_174, &__v_443) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_171, &__v_444) } else { aiur::execute::bytes2_xor_value(__v_171, __v_444, record) }; let __u32_sum: u128 = u128::from((((__v_361.as_canonical_u64() << 0) | (__v_362.as_canonical_u64() << 8)) | (__v_363.as_canonical_u64() << 16)) | (__v_364.as_canonical_u64() << 24)) + u128::from((((__v_452.as_canonical_u64() << 0) | (__v_453.as_canonical_u64() << 8)) | (__v_450.as_canonical_u64() << 16)) | (__v_451.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_454: G = G::from_u8(__u32_bytes[0]); let __v_455: G = G::from_u8(__u32_bytes[1]); let __v_456: G = G::from_u8(__u32_bytes[2]); let __v_457: G = G::from_u8(__u32_bytes[3]); let __v_458: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_454; let __vj = __v_455; 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_456; let __vj = __v_457; 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_459: G = __v_458 * __v_458; if (__v_459 != __v_458) { return Err(ExecError::AssertEqMismatch { lhs: __v_459.as_canonical_u64(), rhs: __v_458.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_313, &__v_454) } else { aiur::execute::bytes2_xor_split4_value(__v_313, __v_454, record) }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_314, &__v_455) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_315, &__v_456) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_464: G = __b2_out.0; let __v_465: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_316, &__v_457) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_466: G = __b2_out.0; let __v_467: G = __b2_out.1; let __v_468: G = __v_462 + __v_465; let __v_469: G = __v_464 + __v_467; let __v_470: G = __v_466 + __v_461; let __v_471: G = __v_460 + __v_463; let __u32_sum: u128 = (u128::from((((__v_441.as_canonical_u64() << 0) | (__v_442.as_canonical_u64() << 8)) | (__v_443.as_canonical_u64() << 16)) | (__v_444.as_canonical_u64() << 24)) + u128::from((((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8)) | (__v_470.as_canonical_u64() << 16)) | (__v_471.as_canonical_u64() << 24))) + u128::from((((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8)) | (__v_110.as_canonical_u64() << 16)) | (__v_111.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_472: G = G::from_u8(__u32_bytes[0]); let __v_473: G = G::from_u8(__u32_bytes[1]); let __v_474: G = G::from_u8(__u32_bytes[2]); let __v_475: G = G::from_u8(__u32_bytes[3]); let __v_476: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_472; let __vj = __v_473; 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_474; let __vj = __v_475; 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_477: G = __v_476 - __v_133; let __v_478: G = __v_476 - __v_135; let __v_479: G = __v_477 * __v_478; let __v_480: G = __v_476 * __v_479; if (__v_480 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_481: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_452, &__v_472) } else { aiur::execute::bytes2_xor_value(__v_452, __v_472, record) }; let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_453, &__v_473) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_450, &__v_474) } else { aiur::execute::bytes2_xor_value(__v_450, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_451, &__v_475) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __u32_sum: u128 = u128::from((((__v_454.as_canonical_u64() << 0) | (__v_455.as_canonical_u64() << 8)) | (__v_456.as_canonical_u64() << 16)) | (__v_457.as_canonical_u64() << 24)) + u128::from((((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8)) | (__v_484.as_canonical_u64() << 16)) | (__v_481.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); let __v_486: G = G::from_u8(__u32_bytes[1]); let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_485; let __vj = __v_486; 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_487; let __vj = __v_488; 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_490: G = __v_489 * __v_489; if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_468, &__v_485) } else { aiur::execute::bytes2_xor_split7_value(__v_468, __v_485, record) }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_469, &__v_486) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_470, &__v_487) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_471, &__v_488) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = __v_491 + __v_494; let __v_500: G = __v_493 + __v_496; let __v_501: G = __v_495 + __v_498; let __v_502: G = __v_497 + __v_492; let __u32_sum: u128 = (u128::from((((__v_286.as_canonical_u64() << 0) | (__v_287.as_canonical_u64() << 8)) | (__v_288.as_canonical_u64() << 16)) | (__v_289.as_canonical_u64() << 24)) + u128::from((((__v_375.as_canonical_u64() << 0) | (__v_376.as_canonical_u64() << 8)) | (__v_377.as_canonical_u64() << 16)) | (__v_378.as_canonical_u64() << 24))) + u128::from((((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8)) | (__v_114.as_canonical_u64() << 16)) | (__v_115.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_503: G = G::from_u8(__u32_bytes[0]); let __v_504: G = G::from_u8(__u32_bytes[1]); let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_503; let __vj = __v_504; 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_505; let __vj = __v_506; 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_508: G = __v_507 - __v_133; let __v_509: G = __v_507 - __v_135; let __v_510: G = __v_508 * __v_509; let __v_511: G = __v_507 * __v_510; if (__v_511 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_512: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_234, &__v_503) } else { aiur::execute::bytes2_xor_value(__v_234, __v_503, record) }; let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_235, &__v_504) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_236, &__v_505) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_233, &__v_506) } else { aiur::execute::bytes2_xor_value(__v_233, __v_506, record) }; let __u32_sum: u128 = u128::from((((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8)) | (__v_177.as_canonical_u64() << 16)) | (__v_178.as_canonical_u64() << 24)) + u128::from((((__v_514.as_canonical_u64() << 0) | (__v_515.as_canonical_u64() << 8)) | (__v_512.as_canonical_u64() << 16)) | (__v_513.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_516: G = G::from_u8(__u32_bytes[0]); let __v_517: G = G::from_u8(__u32_bytes[1]); let __v_518: G = G::from_u8(__u32_bytes[2]); let __v_519: G = G::from_u8(__u32_bytes[3]); let __v_520: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_516; let __vj = __v_517; 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_518; let __vj = __v_519; 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_521: G = __v_520 * __v_520; if (__v_521 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_375, &__v_516) } else { aiur::execute::bytes2_xor_split4_value(__v_375, __v_516, record) }; let __v_522: G = __b2_out.0; let __v_523: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_376, &__v_517) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_377, &__v_518) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_378, &__v_519) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; let __v_530: G = __v_524 + __v_527; let __v_531: G = __v_526 + __v_529; let __v_532: G = __v_528 + __v_523; let __v_533: G = __v_522 + __v_525; let __u32_sum: u128 = (u128::from((((__v_503.as_canonical_u64() << 0) | (__v_504.as_canonical_u64() << 8)) | (__v_505.as_canonical_u64() << 16)) | (__v_506.as_canonical_u64() << 24)) + u128::from((((__v_530.as_canonical_u64() << 0) | (__v_531.as_canonical_u64() << 8)) | (__v_532.as_canonical_u64() << 16)) | (__v_533.as_canonical_u64() << 24))) + u128::from((((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8)) | (__v_118.as_canonical_u64() << 16)) | (__v_119.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_534: G = G::from_u8(__u32_bytes[0]); let __v_535: G = G::from_u8(__u32_bytes[1]); let __v_536: G = G::from_u8(__u32_bytes[2]); let __v_537: G = G::from_u8(__u32_bytes[3]); let __v_538: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_534; let __vj = __v_535; 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_536; let __vj = __v_537; 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_539: G = __v_538 - __v_133; let __v_540: G = __v_538 - __v_135; let __v_541: G = __v_539 * __v_540; let __v_542: G = __v_538 * __v_541; if (__v_542 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_542.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_543: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_514, &__v_534) } else { aiur::execute::bytes2_xor_value(__v_514, __v_534, record) }; let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_515, &__v_535) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_512, &__v_536) } else { aiur::execute::bytes2_xor_value(__v_512, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_513, &__v_537) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __u32_sum: u128 = u128::from((((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8)) | (__v_518.as_canonical_u64() << 16)) | (__v_519.as_canonical_u64() << 24)) + u128::from((((__v_544.as_canonical_u64() << 0) | (__v_545.as_canonical_u64() << 8)) | (__v_546.as_canonical_u64() << 16)) | (__v_543.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_547: G = G::from_u8(__u32_bytes[0]); let __v_548: G = G::from_u8(__u32_bytes[1]); let __v_549: G = G::from_u8(__u32_bytes[2]); let __v_550: G = G::from_u8(__u32_bytes[3]); let __v_551: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_547; let __vj = __v_548; 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_549; let __vj = __v_550; 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_552: G = __v_551 * __v_551; if (__v_552 != __v_551) { return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_551.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_530, &__v_547) } else { aiur::execute::bytes2_xor_split7_value(__v_530, __v_547, record) }; let __v_553: G = __b2_out.0; let __v_554: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_531, &__v_548) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_555: G = __b2_out.0; let __v_556: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_532, &__v_549) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_557: G = __b2_out.0; let __v_558: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_533, &__v_550) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; let __v_561: G = __v_553 + __v_556; let __v_562: G = __v_555 + __v_558; let __v_563: G = __v_557 + __v_560; let __v_564: G = __v_559 + __v_554; let __u32_sum: u128 = (u128::from((((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8)) | (__v_350.as_canonical_u64() << 16)) | (__v_351.as_canonical_u64() << 24)) + u128::from((((__v_189.as_canonical_u64() << 0) | (__v_190.as_canonical_u64() << 8)) | (__v_191.as_canonical_u64() << 16)) | (__v_192.as_canonical_u64() << 24))) + u128::from((((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8)) | (__v_122.as_canonical_u64() << 16)) | (__v_123.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_565: G = G::from_u8(__u32_bytes[0]); let __v_566: G = G::from_u8(__u32_bytes[1]); let __v_567: G = G::from_u8(__u32_bytes[2]); let __v_568: G = G::from_u8(__u32_bytes[3]); let __v_569: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_565; let __vj = __v_566; 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_567; let __vj = __v_568; 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_570: G = __v_569 - __v_133; let __v_571: G = __v_569 - __v_135; let __v_572: G = __v_570 * __v_571; let __v_573: G = __v_569 * __v_572; if (__v_573 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_574: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_296, &__v_565) } else { aiur::execute::bytes2_xor_value(__v_296, __v_565, record) }; let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_297, &__v_566) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_298, &__v_567) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_295, &__v_568) } else { aiur::execute::bytes2_xor_value(__v_295, __v_568, record) }; let __u32_sum: u128 = u128::from((((__v_237.as_canonical_u64() << 0) | (__v_238.as_canonical_u64() << 8)) | (__v_239.as_canonical_u64() << 16)) | (__v_240.as_canonical_u64() << 24)) + u128::from((((__v_576.as_canonical_u64() << 0) | (__v_577.as_canonical_u64() << 8)) | (__v_574.as_canonical_u64() << 16)) | (__v_575.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_578: G = G::from_u8(__u32_bytes[0]); let __v_579: G = G::from_u8(__u32_bytes[1]); let __v_580: G = G::from_u8(__u32_bytes[2]); let __v_581: G = G::from_u8(__u32_bytes[3]); let __v_582: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_578; let __vj = __v_579; 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_580; let __vj = __v_581; 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_583: G = __v_582 * __v_582; if (__v_583 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_583.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_189, &__v_578) } else { aiur::execute::bytes2_xor_split4_value(__v_189, __v_578, record) }; let __v_584: G = __b2_out.0; let __v_585: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_190, &__v_579) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_586: G = __b2_out.0; let __v_587: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_191, &__v_580) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_588: G = __b2_out.0; let __v_589: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_192, &__v_581) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_590: G = __b2_out.0; let __v_591: G = __b2_out.1; let __v_592: G = __v_586 + __v_589; let __v_593: G = __v_588 + __v_591; let __v_594: G = __v_590 + __v_585; let __v_595: G = __v_584 + __v_587; let __u32_sum: u128 = (u128::from((((__v_565.as_canonical_u64() << 0) | (__v_566.as_canonical_u64() << 8)) | (__v_567.as_canonical_u64() << 16)) | (__v_568.as_canonical_u64() << 24)) + u128::from((((__v_592.as_canonical_u64() << 0) | (__v_593.as_canonical_u64() << 8)) | (__v_594.as_canonical_u64() << 16)) | (__v_595.as_canonical_u64() << 24))) + u128::from((((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8)) | (__v_126.as_canonical_u64() << 16)) | (__v_127.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_596: G = G::from_u8(__u32_bytes[0]); let __v_597: G = G::from_u8(__u32_bytes[1]); let __v_598: G = G::from_u8(__u32_bytes[2]); let __v_599: G = G::from_u8(__u32_bytes[3]); let __v_600: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_596; let __vj = __v_597; 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_598; let __vj = __v_599; 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_601: G = __v_600 - __v_133; let __v_602: G = __v_600 - __v_135; let __v_603: G = __v_601 * __v_602; let __v_604: G = __v_600 * __v_603; if (__v_604 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_604.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_605: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_576, &__v_596) } else { aiur::execute::bytes2_xor_value(__v_576, __v_596, record) }; let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_577, &__v_597) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_574, &__v_598) } else { aiur::execute::bytes2_xor_value(__v_574, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_575, &__v_599) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __u32_sum: u128 = u128::from((((__v_578.as_canonical_u64() << 0) | (__v_579.as_canonical_u64() << 8)) | (__v_580.as_canonical_u64() << 16)) | (__v_581.as_canonical_u64() << 24)) + u128::from((((__v_606.as_canonical_u64() << 0) | (__v_607.as_canonical_u64() << 8)) | (__v_608.as_canonical_u64() << 16)) | (__v_605.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_609: G = G::from_u8(__u32_bytes[0]); let __v_610: G = G::from_u8(__u32_bytes[1]); let __v_611: G = G::from_u8(__u32_bytes[2]); let __v_612: G = G::from_u8(__u32_bytes[3]); let __v_613: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_609; let __vj = __v_610; 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_611; let __vj = __v_612; 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_614: G = __v_613 * __v_613; if (__v_614 != __v_613) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_613.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_592, &__v_609) } else { aiur::execute::bytes2_xor_split7_value(__v_592, __v_609, record) }; let __v_615: G = __b2_out.0; let __v_616: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_593, &__v_610) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_617: G = __b2_out.0; let __v_618: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_594, &__v_611) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_619: G = __b2_out.0; let __v_620: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_595, &__v_612) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_621: G = __b2_out.0; let __v_622: G = __b2_out.1; let __v_623: G = __v_615 + __v_618; let __v_624: G = __v_617 + __v_620; let __v_625: G = __v_619 + __v_622; let __v_626: G = __v_621 + __v_616; let __ret: [G; OUT_81] = [__v_410, __v_411, __v_412, __v_413, __v_472, __v_473, __v_474, __v_475, __v_534, __v_535, __v_536, __v_537, __v_596, __v_597, __v_598, __v_599, __v_623, __v_624, __v_625, __v_626, __v_437, __v_438, __v_439, __v_440, __v_499, __v_500, __v_501, __v_502, __v_561, __v_562, __v_563, __v_564, __v_547, __v_548, __v_549, __v_550, __v_609, __v_610, __v_611, __v_612, __v_423, __v_424, __v_425, __v_426, __v_485, __v_486, __v_487, __v_488, __v_482, __v_483, __v_484, __v_481, __v_544, __v_545, __v_546, __v_543, __v_606, __v_607, __v_608, __v_605, __v_420, __v_421, __v_422, __v_419, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_82: usize = 106; const IN_82: usize = 106; const OUT_82: usize = 32; -fn aiur_fn_82(inp: [G; IN_82], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); let __v_109: G = G::from_u64(106); let __v_110: G = G::from_u64(133); let __v_111: G = G::from_u64(174); let __v_112: G = G::from_u64(187); let __v_113: G = G::from_u64(114); let __v_114: G = G::from_u64(243); let __v_115: G = G::from_u64(110); let __v_116: G = G::from_u64(60); let __v_117: G = G::from_u64(58); let __v_118: G = G::from_u64(245); let __v_119: G = G::from_u64(79); let __v_120: G = G::from_u64(165); let __v_121: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_121, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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_106, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_121, __v_121, __v_121, __v_105, __v_121, __v_121, __v_121, __v_32, __v_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 ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __r_arr[2]; let __v_125: G = __r_arr[3]; let __v_126: G = __r_arr[4]; let __v_127: G = __r_arr[5]; let __v_128: G = __r_arr[6]; let __v_129: G = __r_arr[7]; let __v_130: G = __r_arr[8]; let __v_131: G = __r_arr[9]; let __v_132: G = __r_arr[10]; let __v_133: G = __r_arr[11]; let __v_134: G = __r_arr[12]; let __v_135: G = __r_arr[13]; let __v_136: G = __r_arr[14]; let __v_137: G = __r_arr[15]; let __v_138: G = __r_arr[16]; let __v_139: G = __r_arr[17]; let __v_140: G = __r_arr[18]; let __v_141: G = __r_arr[19]; let __v_142: G = __r_arr[20]; let __v_143: G = __r_arr[21]; let __v_144: G = __r_arr[22]; let __v_145: G = __r_arr[23]; let __v_146: G = __r_arr[24]; let __v_147: G = __r_arr[25]; let __v_148: G = __r_arr[26]; let __v_149: G = __r_arr[27]; let __v_150: G = __r_arr[28]; let __v_151: G = __r_arr[29]; let __v_152: G = __r_arr[30]; let __v_153: G = __r_arr[31]; let __ret: [G; OUT_82] = [__v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153]; record.function_queries[82].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_82(inp: [G; IN_82], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); let __v_109: G = G::from_u64(106); let __v_110: G = G::from_u64(133); let __v_111: G = G::from_u64(174); let __v_112: G = G::from_u64(187); let __v_113: G = G::from_u64(114); let __v_114: G = G::from_u64(243); let __v_115: G = G::from_u64(110); let __v_116: G = G::from_u64(60); let __v_117: G = G::from_u64(58); let __v_118: G = G::from_u64(245); let __v_119: G = G::from_u64(79); let __v_120: G = G::from_u64(165); let __v_121: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_121, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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_106, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_121, __v_121, __v_121, __v_105, __v_121, __v_121, __v_121, __v_32, __v_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 ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __r_arr[2]; let __v_125: G = __r_arr[3]; let __v_126: G = __r_arr[4]; let __v_127: G = __r_arr[5]; let __v_128: G = __r_arr[6]; let __v_129: G = __r_arr[7]; let __v_130: G = __r_arr[8]; let __v_131: G = __r_arr[9]; let __v_132: G = __r_arr[10]; let __v_133: G = __r_arr[11]; let __v_134: G = __r_arr[12]; let __v_135: G = __r_arr[13]; let __v_136: G = __r_arr[14]; let __v_137: G = __r_arr[15]; let __v_138: G = __r_arr[16]; let __v_139: G = __r_arr[17]; let __v_140: G = __r_arr[18]; let __v_141: G = __r_arr[19]; let __v_142: G = __r_arr[20]; let __v_143: G = __r_arr[21]; let __v_144: G = __r_arr[22]; let __v_145: G = __r_arr[23]; let __v_146: G = __r_arr[24]; let __v_147: G = __r_arr[25]; let __v_148: G = __r_arr[26]; let __v_149: G = __r_arr[27]; let __v_150: G = __r_arr[28]; let __v_151: G = __r_arr[29]; let __v_152: G = __r_arr[30]; let __v_153: G = __r_arr[31]; let __ret: [G; OUT_82] = [__v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_83: usize = 129; const IN_83: usize = 129; const OUT_83: usize = 32; -fn aiur_fn_83(inp: [G; IN_83], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __v_128: G = inp[128]; match __v_0.as_canonical_u64() { 7u64 => { let __v_129: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_1), (&__v_33)) } else { aiur::execute::bytes2_xor_value(__v_1, __v_33, record) }; let __v_130: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_2), (&__v_34)) } else { aiur::execute::bytes2_xor_value(__v_2, __v_34, record) }; let __v_131: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_3), (&__v_35)) } else { aiur::execute::bytes2_xor_value(__v_3, __v_35, record) }; let __v_132: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_4), (&__v_36)) } else { aiur::execute::bytes2_xor_value(__v_4, __v_36, record) }; let __v_133: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_5), (&__v_37)) } else { aiur::execute::bytes2_xor_value(__v_5, __v_37, record) }; let __v_134: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_6), (&__v_38)) } else { aiur::execute::bytes2_xor_value(__v_6, __v_38, record) }; let __v_135: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_7), (&__v_39)) } else { aiur::execute::bytes2_xor_value(__v_7, __v_39, record) }; let __v_136: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_8), (&__v_40)) } else { aiur::execute::bytes2_xor_value(__v_8, __v_40, record) }; let __v_137: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_9), (&__v_41)) } else { aiur::execute::bytes2_xor_value(__v_9, __v_41, record) }; let __v_138: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_10), (&__v_42)) } else { aiur::execute::bytes2_xor_value(__v_10, __v_42, record) }; let __v_139: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_11), (&__v_43)) } else { aiur::execute::bytes2_xor_value(__v_11, __v_43, record) }; let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_12), (&__v_44)) } else { aiur::execute::bytes2_xor_value(__v_12, __v_44, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_13), (&__v_45)) } else { aiur::execute::bytes2_xor_value(__v_13, __v_45, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_14), (&__v_46)) } else { aiur::execute::bytes2_xor_value(__v_14, __v_46, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_15), (&__v_47)) } else { aiur::execute::bytes2_xor_value(__v_15, __v_47, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_16), (&__v_48)) } else { aiur::execute::bytes2_xor_value(__v_16, __v_48, record) }; let __v_145: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_17), (&__v_49)) } else { aiur::execute::bytes2_xor_value(__v_17, __v_49, record) }; let __v_146: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_18), (&__v_50)) } else { aiur::execute::bytes2_xor_value(__v_18, __v_50, record) }; let __v_147: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_19), (&__v_51)) } else { aiur::execute::bytes2_xor_value(__v_19, __v_51, record) }; let __v_148: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_20), (&__v_52)) } else { aiur::execute::bytes2_xor_value(__v_20, __v_52, record) }; let __v_149: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_21), (&__v_53)) } else { aiur::execute::bytes2_xor_value(__v_21, __v_53, record) }; let __v_150: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_22), (&__v_54)) } else { aiur::execute::bytes2_xor_value(__v_22, __v_54, record) }; let __v_151: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_23), (&__v_55)) } else { aiur::execute::bytes2_xor_value(__v_23, __v_55, record) }; let __v_152: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_24), (&__v_56)) } else { aiur::execute::bytes2_xor_value(__v_24, __v_56, record) }; let __v_153: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_25), (&__v_57)) } else { aiur::execute::bytes2_xor_value(__v_25, __v_57, record) }; let __v_154: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_26), (&__v_58)) } else { aiur::execute::bytes2_xor_value(__v_26, __v_58, record) }; let __v_155: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_27), (&__v_59)) } else { aiur::execute::bytes2_xor_value(__v_27, __v_59, record) }; let __v_156: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_28), (&__v_60)) } else { aiur::execute::bytes2_xor_value(__v_28, __v_60, record) }; let __v_157: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_29), (&__v_61)) } else { aiur::execute::bytes2_xor_value(__v_29, __v_61, record) }; let __v_158: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_30), (&__v_62)) } else { aiur::execute::bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_31), (&__v_63)) } else { aiur::execute::bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_32), (&__v_64)) } else { aiur::execute::bytes2_xor_value(__v_32, __v_64, record) }; let __ret: [G; OUT_83] = [__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]; record.function_queries[83].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = ((u128::from(((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24))) + u128::from(((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24)))) + u128::from(((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; 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_131; let __vj = __v_132; 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_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = G::from_u64(2); let __v_137: G = (__v_133 - __v_136); let __v_138: G = (__v_135 * __v_137); let __v_139: G = (__v_133 * __v_138); let __v_140: G = G::from_u64(0); if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_132)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_132, record) }; let __u32_sum: u128 = (u128::from(((((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8)) | (__v_35.as_canonical_u64() << 16)) | (__v_36.as_canonical_u64() << 24))) + u128::from(((((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8)) | (__v_141.as_canonical_u64() << 16)) | (__v_142.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); let __v_146: G = G::from_u8(__u32_bytes[1]); let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; 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_147; let __vj = __v_148; 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_150: G = (__v_149 * __v_149); if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_148)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_148, record) }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = (__v_153 + __v_156); let __v_160: G = (__v_155 + __v_158); let __v_161: G = (__v_157 + __v_152); let __v_162: G = (__v_151 + __v_154); let __u32_sum: u128 = ((u128::from(((((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8)) | (__v_131.as_canonical_u64() << 16)) | (__v_132.as_canonical_u64() << 24))) + u128::from(((((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8)) | (__v_161.as_canonical_u64() << 16)) | (__v_162.as_canonical_u64() << 24)))) + u128::from(((((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8)) | (__v_71.as_canonical_u64() << 16)) | (__v_72.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_163: G = G::from_u8(__u32_bytes[0]); let __v_164: G = G::from_u8(__u32_bytes[1]); let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_163; let __vj = __v_164; 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_165; let __vj = __v_166; 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_168: G = (__v_167 - __v_134); let __v_169: G = (__v_167 - __v_136); let __v_170: G = (__v_168 * __v_169); let __v_171: G = (__v_167 * __v_170); if (__v_171 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_144), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_144, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __v_175: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_166)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_166, record) }; let __u32_sum: u128 = (u128::from(((((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8)) | (__v_147.as_canonical_u64() << 16)) | (__v_148.as_canonical_u64() << 24))) + u128::from(((((__v_173.as_canonical_u64() << 0) | (__v_174.as_canonical_u64() << 8)) | (__v_175.as_canonical_u64() << 16)) | (__v_172.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_176: G = G::from_u8(__u32_bytes[0]); let __v_177: G = G::from_u8(__u32_bytes[1]); let __v_178: G = G::from_u8(__u32_bytes[2]); let __v_179: G = G::from_u8(__u32_bytes[3]); let __v_180: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_176; let __vj = __v_177; 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_178; let __vj = __v_179; 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_181: G = (__v_180 * __v_180); if (__v_181 != __v_180) { return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_180.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_182: G = __b2_out.0; let __v_183: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_162), (&__v_179)) } else { aiur::execute::bytes2_xor_split7_value(__v_162, __v_179, record) }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; let __v_190: G = (__v_182 + __v_185); let __v_191: G = (__v_184 + __v_187); let __v_192: G = (__v_186 + __v_189); let __v_193: G = (__v_188 + __v_183); let __u32_sum: u128 = ((u128::from(((((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8)) | (__v_7.as_canonical_u64() << 16)) | (__v_8.as_canonical_u64() << 24))) + u128::from(((((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8)) | (__v_23.as_canonical_u64() << 16)) | (__v_24.as_canonical_u64() << 24)))) + u128::from(((((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8)) | (__v_75.as_canonical_u64() << 16)) | (__v_76.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_194: G = G::from_u8(__u32_bytes[0]); let __v_195: G = G::from_u8(__u32_bytes[1]); let __v_196: G = G::from_u8(__u32_bytes[2]); let __v_197: G = G::from_u8(__u32_bytes[3]); let __v_198: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_194; let __vj = __v_195; 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_196; let __vj = __v_197; 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_199: G = (__v_198 - __v_134); let __v_200: G = (__v_198 - __v_136); let __v_201: G = (__v_199 * __v_200); let __v_202: G = (__v_198 * __v_201); if (__v_202 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_202.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __v_206: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_197)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_197, record) }; let __u32_sum: u128 = (u128::from(((((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8)) | (__v_39.as_canonical_u64() << 16)) | (__v_40.as_canonical_u64() << 24))) + u128::from(((((__v_205.as_canonical_u64() << 0) | (__v_206.as_canonical_u64() << 8)) | (__v_203.as_canonical_u64() << 16)) | (__v_204.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_207: G = G::from_u8(__u32_bytes[0]); let __v_208: G = G::from_u8(__u32_bytes[1]); let __v_209: G = G::from_u8(__u32_bytes[2]); let __v_210: G = G::from_u8(__u32_bytes[3]); let __v_211: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_207; let __vj = __v_208; 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_209; let __vj = __v_210; 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_212: G = (__v_211 * __v_211); if (__v_212 != __v_211) { return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_211.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_213: G = __b2_out.0; let __v_214: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_215: G = __b2_out.0; let __v_216: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_217: G = __b2_out.0; let __v_218: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_210)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_210, record) }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; let __v_221: G = (__v_215 + __v_218); let __v_222: G = (__v_217 + __v_220); let __v_223: G = (__v_219 + __v_214); let __v_224: G = (__v_213 + __v_216); let __u32_sum: u128 = ((u128::from(((((__v_194.as_canonical_u64() << 0) | (__v_195.as_canonical_u64() << 8)) | (__v_196.as_canonical_u64() << 16)) | (__v_197.as_canonical_u64() << 24))) + u128::from(((((__v_221.as_canonical_u64() << 0) | (__v_222.as_canonical_u64() << 8)) | (__v_223.as_canonical_u64() << 16)) | (__v_224.as_canonical_u64() << 24)))) + u128::from(((((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8)) | (__v_79.as_canonical_u64() << 16)) | (__v_80.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_225: G = G::from_u8(__u32_bytes[0]); let __v_226: G = G::from_u8(__u32_bytes[1]); let __v_227: G = G::from_u8(__u32_bytes[2]); let __v_228: G = G::from_u8(__u32_bytes[3]); let __v_229: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_225; let __vj = __v_226; 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_227; let __vj = __v_228; 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_230: G = (__v_229 - __v_134); let __v_231: G = (__v_229 - __v_136); let __v_232: G = (__v_230 * __v_231); let __v_233: G = (__v_229 * __v_232); if (__v_233 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_206), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_206, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __v_237: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_228)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_228, record) }; let __u32_sum: u128 = (u128::from(((((__v_207.as_canonical_u64() << 0) | (__v_208.as_canonical_u64() << 8)) | (__v_209.as_canonical_u64() << 16)) | (__v_210.as_canonical_u64() << 24))) + u128::from(((((__v_235.as_canonical_u64() << 0) | (__v_236.as_canonical_u64() << 8)) | (__v_237.as_canonical_u64() << 16)) | (__v_234.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_238: G = G::from_u8(__u32_bytes[0]); let __v_239: G = G::from_u8(__u32_bytes[1]); let __v_240: G = G::from_u8(__u32_bytes[2]); let __v_241: G = G::from_u8(__u32_bytes[3]); let __v_242: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_238; let __vj = __v_239; 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_240; let __vj = __v_241; 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_243: G = (__v_242 * __v_242); if (__v_243 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_244: G = __b2_out.0; let __v_245: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_246: G = __b2_out.0; let __v_247: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_248: G = __b2_out.0; let __v_249: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_224), (&__v_241)) } else { aiur::execute::bytes2_xor_split7_value(__v_224, __v_241, record) }; let __v_250: G = __b2_out.0; let __v_251: G = __b2_out.1; let __v_252: G = (__v_244 + __v_247); let __v_253: G = (__v_246 + __v_249); let __v_254: G = (__v_248 + __v_251); let __v_255: G = (__v_250 + __v_245); let __u32_sum: u128 = ((u128::from(((((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8)) | (__v_11.as_canonical_u64() << 16)) | (__v_12.as_canonical_u64() << 24))) + u128::from(((((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8)) | (__v_27.as_canonical_u64() << 16)) | (__v_28.as_canonical_u64() << 24)))) + u128::from(((((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8)) | (__v_83.as_canonical_u64() << 16)) | (__v_84.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_256: G = G::from_u8(__u32_bytes[0]); let __v_257: G = G::from_u8(__u32_bytes[1]); let __v_258: G = G::from_u8(__u32_bytes[2]); let __v_259: G = G::from_u8(__u32_bytes[3]); let __v_260: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_256; let __vj = __v_257; 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_258; let __vj = __v_259; 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_261: G = (__v_260 - __v_134); let __v_262: G = (__v_260 - __v_136); let __v_263: G = (__v_261 * __v_262); let __v_264: G = (__v_260 * __v_263); if (__v_264 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __v_268: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_259)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_259, record) }; let __u32_sum: u128 = (u128::from(((((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8)) | (__v_43.as_canonical_u64() << 16)) | (__v_44.as_canonical_u64() << 24))) + u128::from(((((__v_267.as_canonical_u64() << 0) | (__v_268.as_canonical_u64() << 8)) | (__v_265.as_canonical_u64() << 16)) | (__v_266.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_269: G = G::from_u8(__u32_bytes[0]); let __v_270: G = G::from_u8(__u32_bytes[1]); let __v_271: G = G::from_u8(__u32_bytes[2]); let __v_272: G = G::from_u8(__u32_bytes[3]); let __v_273: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_269; let __vj = __v_270; 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_271; let __vj = __v_272; 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_274: G = (__v_273 * __v_273); if (__v_274 != __v_273) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_273.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_275: G = __b2_out.0; let __v_276: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_277: G = __b2_out.0; let __v_278: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_279: G = __b2_out.0; let __v_280: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_272)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_272, record) }; let __v_281: G = __b2_out.0; let __v_282: G = __b2_out.1; let __v_283: G = (__v_277 + __v_280); let __v_284: G = (__v_279 + __v_282); let __v_285: G = (__v_281 + __v_276); let __v_286: G = (__v_275 + __v_278); let __u32_sum: u128 = ((u128::from(((((__v_256.as_canonical_u64() << 0) | (__v_257.as_canonical_u64() << 8)) | (__v_258.as_canonical_u64() << 16)) | (__v_259.as_canonical_u64() << 24))) + u128::from(((((__v_283.as_canonical_u64() << 0) | (__v_284.as_canonical_u64() << 8)) | (__v_285.as_canonical_u64() << 16)) | (__v_286.as_canonical_u64() << 24)))) + u128::from(((((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8)) | (__v_87.as_canonical_u64() << 16)) | (__v_88.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_287: G = G::from_u8(__u32_bytes[0]); let __v_288: G = G::from_u8(__u32_bytes[1]); let __v_289: G = G::from_u8(__u32_bytes[2]); let __v_290: G = G::from_u8(__u32_bytes[3]); let __v_291: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_287; let __vj = __v_288; 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_289; let __vj = __v_290; 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_292: G = (__v_291 - __v_134); let __v_293: G = (__v_291 - __v_136); let __v_294: G = (__v_292 * __v_293); let __v_295: G = (__v_291 * __v_294); if (__v_295 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_295.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_268), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_268, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __v_299: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_290)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_290, record) }; let __u32_sum: u128 = (u128::from(((((__v_269.as_canonical_u64() << 0) | (__v_270.as_canonical_u64() << 8)) | (__v_271.as_canonical_u64() << 16)) | (__v_272.as_canonical_u64() << 24))) + u128::from(((((__v_297.as_canonical_u64() << 0) | (__v_298.as_canonical_u64() << 8)) | (__v_299.as_canonical_u64() << 16)) | (__v_296.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_300: G = G::from_u8(__u32_bytes[0]); let __v_301: G = G::from_u8(__u32_bytes[1]); let __v_302: G = G::from_u8(__u32_bytes[2]); let __v_303: G = G::from_u8(__u32_bytes[3]); let __v_304: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_300; let __vj = __v_301; 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_302; let __vj = __v_303; 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_305: G = (__v_304 * __v_304); if (__v_305 != __v_304) { return Err(ExecError::AssertEqMismatch { lhs: __v_305.as_canonical_u64(), rhs: __v_304.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_306: G = __b2_out.0; let __v_307: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_308: G = __b2_out.0; let __v_309: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_310: G = __b2_out.0; let __v_311: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_286), (&__v_303)) } else { aiur::execute::bytes2_xor_split7_value(__v_286, __v_303, record) }; let __v_312: G = __b2_out.0; let __v_313: G = __b2_out.1; let __v_314: G = (__v_306 + __v_309); let __v_315: G = (__v_308 + __v_311); let __v_316: G = (__v_310 + __v_313); let __v_317: G = (__v_312 + __v_307); let __u32_sum: u128 = ((u128::from(((((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8)) | (__v_15.as_canonical_u64() << 16)) | (__v_16.as_canonical_u64() << 24))) + u128::from(((((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8)) | (__v_31.as_canonical_u64() << 16)) | (__v_32.as_canonical_u64() << 24)))) + u128::from(((((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8)) | (__v_91.as_canonical_u64() << 16)) | (__v_92.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_318: G = G::from_u8(__u32_bytes[0]); let __v_319: G = G::from_u8(__u32_bytes[1]); let __v_320: G = G::from_u8(__u32_bytes[2]); let __v_321: G = G::from_u8(__u32_bytes[3]); let __v_322: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_318; let __vj = __v_319; 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_320; let __vj = __v_321; 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_323: G = (__v_322 - __v_134); let __v_324: G = (__v_322 - __v_136); let __v_325: G = (__v_323 * __v_324); let __v_326: G = (__v_322 * __v_325); if (__v_326 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __v_330: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_64), (&__v_321)) } else { aiur::execute::bytes2_xor_value(__v_64, __v_321, record) }; let __u32_sum: u128 = (u128::from(((((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8)) | (__v_47.as_canonical_u64() << 16)) | (__v_48.as_canonical_u64() << 24))) + u128::from(((((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8)) | (__v_327.as_canonical_u64() << 16)) | (__v_328.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_331: G = G::from_u8(__u32_bytes[0]); let __v_332: G = G::from_u8(__u32_bytes[1]); let __v_333: G = G::from_u8(__u32_bytes[2]); let __v_334: G = G::from_u8(__u32_bytes[3]); let __v_335: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_331; let __vj = __v_332; 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_333; let __vj = __v_334; 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_336: G = (__v_335 * __v_335); if (__v_336 != __v_335) { return Err(ExecError::AssertEqMismatch { lhs: __v_336.as_canonical_u64(), rhs: __v_335.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_337: G = __b2_out.0; let __v_338: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_339: G = __b2_out.0; let __v_340: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_341: G = __b2_out.0; let __v_342: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_32), (&__v_334)) } else { aiur::execute::bytes2_xor_split4_value(__v_32, __v_334, record) }; let __v_343: G = __b2_out.0; let __v_344: G = __b2_out.1; let __v_345: G = (__v_339 + __v_342); let __v_346: G = (__v_341 + __v_344); let __v_347: G = (__v_343 + __v_338); let __v_348: G = (__v_337 + __v_340); let __u32_sum: u128 = ((u128::from(((((__v_318.as_canonical_u64() << 0) | (__v_319.as_canonical_u64() << 8)) | (__v_320.as_canonical_u64() << 16)) | (__v_321.as_canonical_u64() << 24))) + u128::from(((((__v_345.as_canonical_u64() << 0) | (__v_346.as_canonical_u64() << 8)) | (__v_347.as_canonical_u64() << 16)) | (__v_348.as_canonical_u64() << 24)))) + u128::from(((((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8)) | (__v_95.as_canonical_u64() << 16)) | (__v_96.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); let __v_350: G = G::from_u8(__u32_bytes[1]); let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_349; let __vj = __v_350; 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_351; let __vj = __v_352; 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_354: G = (__v_353 - __v_134); let __v_355: G = (__v_353 - __v_136); let __v_356: G = (__v_354 * __v_355); let __v_357: G = (__v_353 * __v_356); if (__v_357 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_330), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_330, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __v_361: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_352)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_352, record) }; let __u32_sum: u128 = (u128::from(((((__v_331.as_canonical_u64() << 0) | (__v_332.as_canonical_u64() << 8)) | (__v_333.as_canonical_u64() << 16)) | (__v_334.as_canonical_u64() << 24))) + u128::from(((((__v_359.as_canonical_u64() << 0) | (__v_360.as_canonical_u64() << 8)) | (__v_361.as_canonical_u64() << 16)) | (__v_358.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_362: G = G::from_u8(__u32_bytes[0]); let __v_363: G = G::from_u8(__u32_bytes[1]); let __v_364: G = G::from_u8(__u32_bytes[2]); let __v_365: G = G::from_u8(__u32_bytes[3]); let __v_366: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_362; let __vj = __v_363; 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_364; let __vj = __v_365; 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_367: G = (__v_366 * __v_366); if (__v_367 != __v_366) { return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_366.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_368: G = __b2_out.0; let __v_369: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_370: G = __b2_out.0; let __v_371: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_372: G = __b2_out.0; let __v_373: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_348), (&__v_365)) } else { aiur::execute::bytes2_xor_split7_value(__v_348, __v_365, record) }; let __v_374: G = __b2_out.0; let __v_375: G = __b2_out.1; let __v_376: G = (__v_368 + __v_371); let __v_377: G = (__v_370 + __v_373); let __v_378: G = (__v_372 + __v_375); let __v_379: G = (__v_374 + __v_369); let __u32_sum: u128 = ((u128::from(((((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8)) | (__v_165.as_canonical_u64() << 16)) | (__v_166.as_canonical_u64() << 24))) + u128::from(((((__v_252.as_canonical_u64() << 0) | (__v_253.as_canonical_u64() << 8)) | (__v_254.as_canonical_u64() << 16)) | (__v_255.as_canonical_u64() << 24)))) + u128::from(((((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8)) | (__v_99.as_canonical_u64() << 16)) | (__v_100.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_380: G = G::from_u8(__u32_bytes[0]); let __v_381: G = G::from_u8(__u32_bytes[1]); let __v_382: G = G::from_u8(__u32_bytes[2]); let __v_383: G = G::from_u8(__u32_bytes[3]); let __v_384: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_380; let __vj = __v_381; 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_382; let __vj = __v_383; 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_385: G = (__v_384 - __v_134); let __v_386: G = (__v_384 - __v_136); let __v_387: G = (__v_385 * __v_386); let __v_388: G = (__v_384 * __v_387); if (__v_388 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_361), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_361, __v_382, record) }; let __v_392: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_383)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_383, record) }; let __u32_sum: u128 = (u128::from(((((__v_300.as_canonical_u64() << 0) | (__v_301.as_canonical_u64() << 8)) | (__v_302.as_canonical_u64() << 16)) | (__v_303.as_canonical_u64() << 24))) + u128::from(((((__v_391.as_canonical_u64() << 0) | (__v_392.as_canonical_u64() << 8)) | (__v_389.as_canonical_u64() << 16)) | (__v_390.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_393: G = G::from_u8(__u32_bytes[0]); let __v_394: G = G::from_u8(__u32_bytes[1]); let __v_395: G = G::from_u8(__u32_bytes[2]); let __v_396: G = G::from_u8(__u32_bytes[3]); let __v_397: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_393; let __vj = __v_394; 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_395; let __vj = __v_396; 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_398: G = (__v_397 * __v_397); if (__v_398 != __v_397) { return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_397.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_399: G = __b2_out.0; let __v_400: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_401: G = __b2_out.0; let __v_402: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_403: G = __b2_out.0; let __v_404: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_255), (&__v_396)) } else { aiur::execute::bytes2_xor_split4_value(__v_255, __v_396, record) }; let __v_405: G = __b2_out.0; let __v_406: G = __b2_out.1; let __v_407: G = (__v_401 + __v_404); let __v_408: G = (__v_403 + __v_406); let __v_409: G = (__v_405 + __v_400); let __v_410: G = (__v_399 + __v_402); let __u32_sum: u128 = ((u128::from(((((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8)) | (__v_382.as_canonical_u64() << 16)) | (__v_383.as_canonical_u64() << 24))) + u128::from(((((__v_407.as_canonical_u64() << 0) | (__v_408.as_canonical_u64() << 8)) | (__v_409.as_canonical_u64() << 16)) | (__v_410.as_canonical_u64() << 24)))) + u128::from(((((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8)) | (__v_103.as_canonical_u64() << 16)) | (__v_104.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_411: G = G::from_u8(__u32_bytes[0]); let __v_412: G = G::from_u8(__u32_bytes[1]); let __v_413: G = G::from_u8(__u32_bytes[2]); let __v_414: G = G::from_u8(__u32_bytes[3]); let __v_415: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_411; let __vj = __v_412; 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_413; let __vj = __v_414; 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_416: G = (__v_415 - __v_134); let __v_417: G = (__v_415 - __v_136); let __v_418: G = (__v_416 * __v_417); let __v_419: G = (__v_415 * __v_418); if (__v_419 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_392), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_392, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __v_423: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_414)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_414, record) }; let __u32_sum: u128 = (u128::from(((((__v_393.as_canonical_u64() << 0) | (__v_394.as_canonical_u64() << 8)) | (__v_395.as_canonical_u64() << 16)) | (__v_396.as_canonical_u64() << 24))) + u128::from(((((__v_421.as_canonical_u64() << 0) | (__v_422.as_canonical_u64() << 8)) | (__v_423.as_canonical_u64() << 16)) | (__v_420.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_424: G = G::from_u8(__u32_bytes[0]); let __v_425: G = G::from_u8(__u32_bytes[1]); let __v_426: G = G::from_u8(__u32_bytes[2]); let __v_427: G = G::from_u8(__u32_bytes[3]); let __v_428: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_424; let __vj = __v_425; 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_426; let __vj = __v_427; 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_429: G = (__v_428 * __v_428); if (__v_429 != __v_428) { return Err(ExecError::AssertEqMismatch { lhs: __v_429.as_canonical_u64(), rhs: __v_428.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_430: G = __b2_out.0; let __v_431: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_432: G = __b2_out.0; let __v_433: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_434: G = __b2_out.0; let __v_435: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_410), (&__v_427)) } else { aiur::execute::bytes2_xor_split7_value(__v_410, __v_427, record) }; let __v_436: G = __b2_out.0; let __v_437: G = __b2_out.1; let __v_438: G = (__v_430 + __v_433); let __v_439: G = (__v_432 + __v_435); let __v_440: G = (__v_434 + __v_437); let __v_441: G = (__v_436 + __v_431); let __u32_sum: u128 = ((u128::from(((((__v_225.as_canonical_u64() << 0) | (__v_226.as_canonical_u64() << 8)) | (__v_227.as_canonical_u64() << 16)) | (__v_228.as_canonical_u64() << 24))) + u128::from(((((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8)) | (__v_316.as_canonical_u64() << 16)) | (__v_317.as_canonical_u64() << 24)))) + u128::from(((((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8)) | (__v_107.as_canonical_u64() << 16)) | (__v_108.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_442: G = G::from_u8(__u32_bytes[0]); let __v_443: G = G::from_u8(__u32_bytes[1]); let __v_444: G = G::from_u8(__u32_bytes[2]); let __v_445: G = G::from_u8(__u32_bytes[3]); let __v_446: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_442; let __vj = __v_443; 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_444; let __vj = __v_445; 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_447: G = (__v_446 - __v_134); let __v_448: G = (__v_446 - __v_136); let __v_449: G = (__v_447 * __v_448); let __v_450: G = (__v_446 * __v_449); if (__v_450 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_450.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_175), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_175, __v_444, record) }; let __v_454: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_445)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_445, record) }; let __u32_sum: u128 = (u128::from(((((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8)) | (__v_364.as_canonical_u64() << 16)) | (__v_365.as_canonical_u64() << 24))) + u128::from(((((__v_453.as_canonical_u64() << 0) | (__v_454.as_canonical_u64() << 8)) | (__v_451.as_canonical_u64() << 16)) | (__v_452.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_455: G = G::from_u8(__u32_bytes[0]); let __v_456: G = G::from_u8(__u32_bytes[1]); let __v_457: G = G::from_u8(__u32_bytes[2]); let __v_458: G = G::from_u8(__u32_bytes[3]); let __v_459: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_455; let __vj = __v_456; 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_457; let __vj = __v_458; 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_460: G = (__v_459 * __v_459); if (__v_460 != __v_459) { return Err(ExecError::AssertEqMismatch { lhs: __v_460.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_465: G = __b2_out.0; let __v_466: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_317), (&__v_458)) } else { aiur::execute::bytes2_xor_split4_value(__v_317, __v_458, record) }; let __v_467: G = __b2_out.0; let __v_468: G = __b2_out.1; let __v_469: G = (__v_463 + __v_466); let __v_470: G = (__v_465 + __v_468); let __v_471: G = (__v_467 + __v_462); let __v_472: G = (__v_461 + __v_464); let __u32_sum: u128 = ((u128::from(((((__v_442.as_canonical_u64() << 0) | (__v_443.as_canonical_u64() << 8)) | (__v_444.as_canonical_u64() << 16)) | (__v_445.as_canonical_u64() << 24))) + u128::from(((((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8)) | (__v_471.as_canonical_u64() << 16)) | (__v_472.as_canonical_u64() << 24)))) + u128::from(((((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8)) | (__v_111.as_canonical_u64() << 16)) | (__v_112.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_473: G = G::from_u8(__u32_bytes[0]); let __v_474: G = G::from_u8(__u32_bytes[1]); let __v_475: G = G::from_u8(__u32_bytes[2]); let __v_476: G = G::from_u8(__u32_bytes[3]); let __v_477: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_473; let __vj = __v_474; 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_475; let __vj = __v_476; 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_478: G = (__v_477 - __v_134); let __v_479: G = (__v_477 - __v_136); let __v_480: G = (__v_478 * __v_479); let __v_481: G = (__v_477 * __v_480); if (__v_481 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_481.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_454), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_454, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __v_485: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_476)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_476, record) }; let __u32_sum: u128 = (u128::from(((((__v_455.as_canonical_u64() << 0) | (__v_456.as_canonical_u64() << 8)) | (__v_457.as_canonical_u64() << 16)) | (__v_458.as_canonical_u64() << 24))) + u128::from(((((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8)) | (__v_485.as_canonical_u64() << 16)) | (__v_482.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_486: G = G::from_u8(__u32_bytes[0]); let __v_487: G = G::from_u8(__u32_bytes[1]); let __v_488: G = G::from_u8(__u32_bytes[2]); let __v_489: G = G::from_u8(__u32_bytes[3]); let __v_490: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_486; let __vj = __v_487; 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_488; let __vj = __v_489; 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_491: G = (__v_490 * __v_490); if (__v_491 != __v_490) { return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_472), (&__v_489)) } else { aiur::execute::bytes2_xor_split7_value(__v_472, __v_489, record) }; let __v_498: G = __b2_out.0; let __v_499: G = __b2_out.1; let __v_500: G = (__v_492 + __v_495); let __v_501: G = (__v_494 + __v_497); let __v_502: G = (__v_496 + __v_499); let __v_503: G = (__v_498 + __v_493); let __u32_sum: u128 = ((u128::from(((((__v_287.as_canonical_u64() << 0) | (__v_288.as_canonical_u64() << 8)) | (__v_289.as_canonical_u64() << 16)) | (__v_290.as_canonical_u64() << 24))) + u128::from(((((__v_376.as_canonical_u64() << 0) | (__v_377.as_canonical_u64() << 8)) | (__v_378.as_canonical_u64() << 16)) | (__v_379.as_canonical_u64() << 24)))) + u128::from(((((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8)) | (__v_115.as_canonical_u64() << 16)) | (__v_116.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_504: G = G::from_u8(__u32_bytes[0]); let __v_505: G = G::from_u8(__u32_bytes[1]); let __v_506: G = G::from_u8(__u32_bytes[2]); let __v_507: G = G::from_u8(__u32_bytes[3]); let __v_508: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_504; let __vj = __v_505; 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_506; let __vj = __v_507; 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_509: G = (__v_508 - __v_134); let __v_510: G = (__v_508 - __v_136); let __v_511: G = (__v_509 * __v_510); let __v_512: G = (__v_508 * __v_511); if (__v_512 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_237), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_237, __v_506, record) }; let __v_516: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_507)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_507, record) }; let __u32_sum: u128 = (u128::from(((((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8)) | (__v_178.as_canonical_u64() << 16)) | (__v_179.as_canonical_u64() << 24))) + u128::from(((((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8)) | (__v_513.as_canonical_u64() << 16)) | (__v_514.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_517: G = G::from_u8(__u32_bytes[0]); let __v_518: G = G::from_u8(__u32_bytes[1]); let __v_519: G = G::from_u8(__u32_bytes[2]); let __v_520: G = G::from_u8(__u32_bytes[3]); let __v_521: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_517; let __vj = __v_518; 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_519; let __vj = __v_520; 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_522: G = (__v_521 * __v_521); if (__v_522 != __v_521) { return Err(ExecError::AssertEqMismatch { lhs: __v_522.as_canonical_u64(), rhs: __v_521.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_523: G = __b2_out.0; let __v_524: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_379), (&__v_520)) } else { aiur::execute::bytes2_xor_split4_value(__v_379, __v_520, record) }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; let __v_531: G = (__v_525 + __v_528); let __v_532: G = (__v_527 + __v_530); let __v_533: G = (__v_529 + __v_524); let __v_534: G = (__v_523 + __v_526); let __u32_sum: u128 = ((u128::from(((((__v_504.as_canonical_u64() << 0) | (__v_505.as_canonical_u64() << 8)) | (__v_506.as_canonical_u64() << 16)) | (__v_507.as_canonical_u64() << 24))) + u128::from(((((__v_531.as_canonical_u64() << 0) | (__v_532.as_canonical_u64() << 8)) | (__v_533.as_canonical_u64() << 16)) | (__v_534.as_canonical_u64() << 24)))) + u128::from(((((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8)) | (__v_119.as_canonical_u64() << 16)) | (__v_120.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_535: G = G::from_u8(__u32_bytes[0]); let __v_536: G = G::from_u8(__u32_bytes[1]); let __v_537: G = G::from_u8(__u32_bytes[2]); let __v_538: G = G::from_u8(__u32_bytes[3]); let __v_539: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_535; let __vj = __v_536; 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_537; let __vj = __v_538; 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_540: G = (__v_539 - __v_134); let __v_541: G = (__v_539 - __v_136); let __v_542: G = (__v_540 * __v_541); let __v_543: G = (__v_539 * __v_542); if (__v_543 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_516), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_516, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __v_547: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_538)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_538, record) }; let __u32_sum: u128 = (u128::from(((((__v_517.as_canonical_u64() << 0) | (__v_518.as_canonical_u64() << 8)) | (__v_519.as_canonical_u64() << 16)) | (__v_520.as_canonical_u64() << 24))) + u128::from(((((__v_545.as_canonical_u64() << 0) | (__v_546.as_canonical_u64() << 8)) | (__v_547.as_canonical_u64() << 16)) | (__v_544.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_548: G = G::from_u8(__u32_bytes[0]); let __v_549: G = G::from_u8(__u32_bytes[1]); let __v_550: G = G::from_u8(__u32_bytes[2]); let __v_551: G = G::from_u8(__u32_bytes[3]); let __v_552: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_548; let __vj = __v_549; 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_550; let __vj = __v_551; 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_553: G = (__v_552 * __v_552); if (__v_553 != __v_552) { return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_552.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_554: G = __b2_out.0; let __v_555: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_556: G = __b2_out.0; let __v_557: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_534), (&__v_551)) } else { aiur::execute::bytes2_xor_split7_value(__v_534, __v_551, record) }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; let __v_562: G = (__v_554 + __v_557); let __v_563: G = (__v_556 + __v_559); let __v_564: G = (__v_558 + __v_561); let __v_565: G = (__v_560 + __v_555); let __u32_sum: u128 = ((u128::from(((((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8)) | (__v_351.as_canonical_u64() << 16)) | (__v_352.as_canonical_u64() << 24))) + u128::from(((((__v_190.as_canonical_u64() << 0) | (__v_191.as_canonical_u64() << 8)) | (__v_192.as_canonical_u64() << 16)) | (__v_193.as_canonical_u64() << 24)))) + u128::from(((((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8)) | (__v_123.as_canonical_u64() << 16)) | (__v_124.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_566: G = G::from_u8(__u32_bytes[0]); let __v_567: G = G::from_u8(__u32_bytes[1]); let __v_568: G = G::from_u8(__u32_bytes[2]); let __v_569: G = G::from_u8(__u32_bytes[3]); let __v_570: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_566; let __vj = __v_567; 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_568; let __vj = __v_569; 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_571: G = (__v_570 - __v_134); let __v_572: G = (__v_570 - __v_136); let __v_573: G = (__v_571 * __v_572); let __v_574: G = (__v_570 * __v_573); if (__v_574 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_574.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_299), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_299, __v_568, record) }; let __v_578: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_569)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_569, record) }; let __u32_sum: u128 = (u128::from(((((__v_238.as_canonical_u64() << 0) | (__v_239.as_canonical_u64() << 8)) | (__v_240.as_canonical_u64() << 16)) | (__v_241.as_canonical_u64() << 24))) + u128::from(((((__v_577.as_canonical_u64() << 0) | (__v_578.as_canonical_u64() << 8)) | (__v_575.as_canonical_u64() << 16)) | (__v_576.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_579: G = G::from_u8(__u32_bytes[0]); let __v_580: G = G::from_u8(__u32_bytes[1]); let __v_581: G = G::from_u8(__u32_bytes[2]); let __v_582: G = G::from_u8(__u32_bytes[3]); let __v_583: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_579; let __vj = __v_580; 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_581; let __vj = __v_582; 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_584: G = (__v_583 * __v_583); if (__v_584 != __v_583) { return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_583.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_585: G = __b2_out.0; let __v_586: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_587: G = __b2_out.0; let __v_588: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_589: G = __b2_out.0; let __v_590: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_193), (&__v_582)) } else { aiur::execute::bytes2_xor_split4_value(__v_193, __v_582, record) }; let __v_591: G = __b2_out.0; let __v_592: G = __b2_out.1; let __v_593: G = (__v_587 + __v_590); let __v_594: G = (__v_589 + __v_592); let __v_595: G = (__v_591 + __v_586); let __v_596: G = (__v_585 + __v_588); let __u32_sum: u128 = ((u128::from(((((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8)) | (__v_568.as_canonical_u64() << 16)) | (__v_569.as_canonical_u64() << 24))) + u128::from(((((__v_593.as_canonical_u64() << 0) | (__v_594.as_canonical_u64() << 8)) | (__v_595.as_canonical_u64() << 16)) | (__v_596.as_canonical_u64() << 24)))) + u128::from(((((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8)) | (__v_127.as_canonical_u64() << 16)) | (__v_128.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_597: G = G::from_u8(__u32_bytes[0]); let __v_598: G = G::from_u8(__u32_bytes[1]); let __v_599: G = G::from_u8(__u32_bytes[2]); let __v_600: G = G::from_u8(__u32_bytes[3]); let __v_601: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_597; let __vj = __v_598; 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_599; let __vj = __v_600; 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_602: G = (__v_601 - __v_134); let __v_603: G = (__v_601 - __v_136); let __v_604: G = (__v_602 * __v_603); let __v_605: G = (__v_601 * __v_604); if (__v_605 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_605.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_578), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_578, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __v_609: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_600)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_600, record) }; let __u32_sum: u128 = (u128::from(((((__v_579.as_canonical_u64() << 0) | (__v_580.as_canonical_u64() << 8)) | (__v_581.as_canonical_u64() << 16)) | (__v_582.as_canonical_u64() << 24))) + u128::from(((((__v_607.as_canonical_u64() << 0) | (__v_608.as_canonical_u64() << 8)) | (__v_609.as_canonical_u64() << 16)) | (__v_606.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_610: G = G::from_u8(__u32_bytes[0]); let __v_611: G = G::from_u8(__u32_bytes[1]); let __v_612: G = G::from_u8(__u32_bytes[2]); let __v_613: G = G::from_u8(__u32_bytes[3]); let __v_614: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_610; let __vj = __v_611; 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_612; let __vj = __v_613; 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_615: G = (__v_614 * __v_614); if (__v_615 != __v_614) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_614.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_616: G = __b2_out.0; let __v_617: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_618: G = __b2_out.0; let __v_619: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_620: G = __b2_out.0; let __v_621: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_596), (&__v_613)) } else { aiur::execute::bytes2_xor_split7_value(__v_596, __v_613, record) }; let __v_622: G = __b2_out.0; let __v_623: G = __b2_out.1; let __v_624: G = (__v_616 + __v_619); let __v_625: G = (__v_618 + __v_621); let __v_626: G = (__v_620 + __v_623); let __v_627: G = (__v_622 + __v_617); let __v_628: G = (__v_0 + __v_134); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_628, __v_411, __v_412, __v_413, __v_414, __v_473, __v_474, __v_475, __v_476, __v_535, __v_536, __v_537, __v_538, __v_597, __v_598, __v_599, __v_600, __v_624, __v_625, __v_626, __v_627, __v_438, __v_439, __v_440, __v_441, __v_500, __v_501, __v_502, __v_503, __v_562, __v_563, __v_564, __v_565, __v_548, __v_549, __v_550, __v_551, __v_610, __v_611, __v_612, __v_613, __v_424, __v_425, __v_426, __v_427, __v_486, __v_487, __v_488, __v_489, __v_483, __v_484, __v_485, __v_482, __v_545, __v_546, __v_547, __v_544, __v_607, __v_608, __v_609, __v_606, __v_421, __v_422, __v_423, __v_420, __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 ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_629: G = __r_arr[0]; let __v_630: G = __r_arr[1]; let __v_631: G = __r_arr[2]; let __v_632: G = __r_arr[3]; let __v_633: G = __r_arr[4]; let __v_634: G = __r_arr[5]; let __v_635: G = __r_arr[6]; let __v_636: G = __r_arr[7]; let __v_637: G = __r_arr[8]; let __v_638: G = __r_arr[9]; let __v_639: G = __r_arr[10]; let __v_640: G = __r_arr[11]; let __v_641: G = __r_arr[12]; let __v_642: G = __r_arr[13]; let __v_643: G = __r_arr[14]; let __v_644: G = __r_arr[15]; let __v_645: G = __r_arr[16]; let __v_646: G = __r_arr[17]; let __v_647: G = __r_arr[18]; let __v_648: G = __r_arr[19]; let __v_649: G = __r_arr[20]; let __v_650: G = __r_arr[21]; let __v_651: G = __r_arr[22]; let __v_652: G = __r_arr[23]; let __v_653: G = __r_arr[24]; let __v_654: G = __r_arr[25]; let __v_655: G = __r_arr[26]; let __v_656: G = __r_arr[27]; let __v_657: G = __r_arr[28]; let __v_658: G = __r_arr[29]; let __v_659: G = __r_arr[30]; let __v_660: G = __r_arr[31]; let __ret: [G; OUT_83] = [__v_629, __v_630, __v_631, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660]; record.function_queries[83].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_83(inp: [G; IN_83], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __v_128: G = inp[128]; match __v_0.as_canonical_u64() { 7u64 => { let __v_129: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_33) } else { aiur::execute::bytes2_xor_value(__v_1, __v_33, record) }; let __v_130: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_34) } else { aiur::execute::bytes2_xor_value(__v_2, __v_34, record) }; let __v_131: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_35) } else { aiur::execute::bytes2_xor_value(__v_3, __v_35, record) }; let __v_132: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_4, &__v_36) } else { aiur::execute::bytes2_xor_value(__v_4, __v_36, record) }; let __v_133: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_5, &__v_37) } else { aiur::execute::bytes2_xor_value(__v_5, __v_37, record) }; let __v_134: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_6, &__v_38) } else { aiur::execute::bytes2_xor_value(__v_6, __v_38, record) }; let __v_135: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_7, &__v_39) } else { aiur::execute::bytes2_xor_value(__v_7, __v_39, record) }; let __v_136: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_8, &__v_40) } else { aiur::execute::bytes2_xor_value(__v_8, __v_40, record) }; let __v_137: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_9, &__v_41) } else { aiur::execute::bytes2_xor_value(__v_9, __v_41, record) }; let __v_138: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_10, &__v_42) } else { aiur::execute::bytes2_xor_value(__v_10, __v_42, record) }; let __v_139: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_11, &__v_43) } else { aiur::execute::bytes2_xor_value(__v_11, __v_43, record) }; let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_12, &__v_44) } else { aiur::execute::bytes2_xor_value(__v_12, __v_44, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_13, &__v_45) } else { aiur::execute::bytes2_xor_value(__v_13, __v_45, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_14, &__v_46) } else { aiur::execute::bytes2_xor_value(__v_14, __v_46, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_15, &__v_47) } else { aiur::execute::bytes2_xor_value(__v_15, __v_47, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_16, &__v_48) } else { aiur::execute::bytes2_xor_value(__v_16, __v_48, record) }; let __v_145: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_17, &__v_49) } else { aiur::execute::bytes2_xor_value(__v_17, __v_49, record) }; let __v_146: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_18, &__v_50) } else { aiur::execute::bytes2_xor_value(__v_18, __v_50, record) }; let __v_147: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_19, &__v_51) } else { aiur::execute::bytes2_xor_value(__v_19, __v_51, record) }; let __v_148: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_20, &__v_52) } else { aiur::execute::bytes2_xor_value(__v_20, __v_52, record) }; let __v_149: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_21, &__v_53) } else { aiur::execute::bytes2_xor_value(__v_21, __v_53, record) }; let __v_150: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_22, &__v_54) } else { aiur::execute::bytes2_xor_value(__v_22, __v_54, record) }; let __v_151: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_23, &__v_55) } else { aiur::execute::bytes2_xor_value(__v_23, __v_55, record) }; let __v_152: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_24, &__v_56) } else { aiur::execute::bytes2_xor_value(__v_24, __v_56, record) }; let __v_153: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_25, &__v_57) } else { aiur::execute::bytes2_xor_value(__v_25, __v_57, record) }; let __v_154: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_26, &__v_58) } else { aiur::execute::bytes2_xor_value(__v_26, __v_58, record) }; let __v_155: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_27, &__v_59) } else { aiur::execute::bytes2_xor_value(__v_27, __v_59, record) }; let __v_156: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_28, &__v_60) } else { aiur::execute::bytes2_xor_value(__v_28, __v_60, record) }; let __v_157: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_29, &__v_61) } else { aiur::execute::bytes2_xor_value(__v_29, __v_61, record) }; let __v_158: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_30, &__v_62) } else { aiur::execute::bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_31, &__v_63) } else { aiur::execute::bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_32, &__v_64) } else { aiur::execute::bytes2_xor_value(__v_32, __v_64, record) }; let __ret: [G; OUT_83] = [__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]; record.function_queries[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = (u128::from((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24)) + u128::from((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24))) + u128::from((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; 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_131; let __vj = __v_132; 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_134: G = G::from_u64(1); let __v_135: G = __v_133 - __v_134; let __v_136: G = G::from_u64(2); let __v_137: G = __v_133 - __v_136; let __v_138: G = __v_135 * __v_137; let __v_139: G = __v_133 * __v_138; let __v_140: G = G::from_u64(0); if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_49, &__v_129) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_50, &__v_130) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_51, &__v_131) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_52, &__v_132) } else { aiur::execute::bytes2_xor_value(__v_52, __v_132, record) }; let __u32_sum: u128 = u128::from((((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8)) | (__v_35.as_canonical_u64() << 16)) | (__v_36.as_canonical_u64() << 24)) + u128::from((((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8)) | (__v_141.as_canonical_u64() << 16)) | (__v_142.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); let __v_146: G = G::from_u8(__u32_bytes[1]); let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; 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_147; let __vj = __v_148; 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_150: G = __v_149 * __v_149; if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_17, &__v_145) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_18, &__v_146) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_19, &__v_147) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_20, &__v_148) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_148, record) }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = __v_153 + __v_156; let __v_160: G = __v_155 + __v_158; let __v_161: G = __v_157 + __v_152; let __v_162: G = __v_151 + __v_154; let __u32_sum: u128 = (u128::from((((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8)) | (__v_131.as_canonical_u64() << 16)) | (__v_132.as_canonical_u64() << 24)) + u128::from((((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8)) | (__v_161.as_canonical_u64() << 16)) | (__v_162.as_canonical_u64() << 24))) + u128::from((((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8)) | (__v_71.as_canonical_u64() << 16)) | (__v_72.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_163: G = G::from_u8(__u32_bytes[0]); let __v_164: G = G::from_u8(__u32_bytes[1]); let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_163; let __vj = __v_164; 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_165; let __vj = __v_166; 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_168: G = __v_167 - __v_134; let __v_169: G = __v_167 - __v_136; let __v_170: G = __v_168 * __v_169; let __v_171: G = __v_167 * __v_170; if (__v_171 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_143, &__v_163) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_144, &__v_164) } else { aiur::execute::bytes2_xor_value(__v_144, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_141, &__v_165) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __v_175: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_142, &__v_166) } else { aiur::execute::bytes2_xor_value(__v_142, __v_166, record) }; let __u32_sum: u128 = u128::from((((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8)) | (__v_147.as_canonical_u64() << 16)) | (__v_148.as_canonical_u64() << 24)) + u128::from((((__v_173.as_canonical_u64() << 0) | (__v_174.as_canonical_u64() << 8)) | (__v_175.as_canonical_u64() << 16)) | (__v_172.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_176: G = G::from_u8(__u32_bytes[0]); let __v_177: G = G::from_u8(__u32_bytes[1]); let __v_178: G = G::from_u8(__u32_bytes[2]); let __v_179: G = G::from_u8(__u32_bytes[3]); let __v_180: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_176; let __vj = __v_177; 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_178; let __vj = __v_179; 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_181: G = __v_180 * __v_180; if (__v_181 != __v_180) { return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_180.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_159, &__v_176) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_182: G = __b2_out.0; let __v_183: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_160, &__v_177) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_161, &__v_178) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_162, &__v_179) } else { aiur::execute::bytes2_xor_split7_value(__v_162, __v_179, record) }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; let __v_190: G = __v_182 + __v_185; let __v_191: G = __v_184 + __v_187; let __v_192: G = __v_186 + __v_189; let __v_193: G = __v_188 + __v_183; let __u32_sum: u128 = (u128::from((((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8)) | (__v_7.as_canonical_u64() << 16)) | (__v_8.as_canonical_u64() << 24)) + u128::from((((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8)) | (__v_23.as_canonical_u64() << 16)) | (__v_24.as_canonical_u64() << 24))) + u128::from((((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8)) | (__v_75.as_canonical_u64() << 16)) | (__v_76.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_194: G = G::from_u8(__u32_bytes[0]); let __v_195: G = G::from_u8(__u32_bytes[1]); let __v_196: G = G::from_u8(__u32_bytes[2]); let __v_197: G = G::from_u8(__u32_bytes[3]); let __v_198: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_194; let __vj = __v_195; 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_196; let __vj = __v_197; 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_199: G = __v_198 - __v_134; let __v_200: G = __v_198 - __v_136; let __v_201: G = __v_199 * __v_200; let __v_202: G = __v_198 * __v_201; if (__v_202 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_202.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_53, &__v_194) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_54, &__v_195) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_55, &__v_196) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __v_206: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_56, &__v_197) } else { aiur::execute::bytes2_xor_value(__v_56, __v_197, record) }; let __u32_sum: u128 = u128::from((((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8)) | (__v_39.as_canonical_u64() << 16)) | (__v_40.as_canonical_u64() << 24)) + u128::from((((__v_205.as_canonical_u64() << 0) | (__v_206.as_canonical_u64() << 8)) | (__v_203.as_canonical_u64() << 16)) | (__v_204.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_207: G = G::from_u8(__u32_bytes[0]); let __v_208: G = G::from_u8(__u32_bytes[1]); let __v_209: G = G::from_u8(__u32_bytes[2]); let __v_210: G = G::from_u8(__u32_bytes[3]); let __v_211: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_207; let __vj = __v_208; 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_209; let __vj = __v_210; 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_212: G = __v_211 * __v_211; if (__v_212 != __v_211) { return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_211.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_21, &__v_207) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_213: G = __b2_out.0; let __v_214: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_22, &__v_208) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_215: G = __b2_out.0; let __v_216: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_23, &__v_209) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_217: G = __b2_out.0; let __v_218: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_24, &__v_210) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_210, record) }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; let __v_221: G = __v_215 + __v_218; let __v_222: G = __v_217 + __v_220; let __v_223: G = __v_219 + __v_214; let __v_224: G = __v_213 + __v_216; let __u32_sum: u128 = (u128::from((((__v_194.as_canonical_u64() << 0) | (__v_195.as_canonical_u64() << 8)) | (__v_196.as_canonical_u64() << 16)) | (__v_197.as_canonical_u64() << 24)) + u128::from((((__v_221.as_canonical_u64() << 0) | (__v_222.as_canonical_u64() << 8)) | (__v_223.as_canonical_u64() << 16)) | (__v_224.as_canonical_u64() << 24))) + u128::from((((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8)) | (__v_79.as_canonical_u64() << 16)) | (__v_80.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_225: G = G::from_u8(__u32_bytes[0]); let __v_226: G = G::from_u8(__u32_bytes[1]); let __v_227: G = G::from_u8(__u32_bytes[2]); let __v_228: G = G::from_u8(__u32_bytes[3]); let __v_229: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_225; let __vj = __v_226; 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_227; let __vj = __v_228; 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_230: G = __v_229 - __v_134; let __v_231: G = __v_229 - __v_136; let __v_232: G = __v_230 * __v_231; let __v_233: G = __v_229 * __v_232; if (__v_233 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_205, &__v_225) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_206, &__v_226) } else { aiur::execute::bytes2_xor_value(__v_206, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_203, &__v_227) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __v_237: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_204, &__v_228) } else { aiur::execute::bytes2_xor_value(__v_204, __v_228, record) }; let __u32_sum: u128 = u128::from((((__v_207.as_canonical_u64() << 0) | (__v_208.as_canonical_u64() << 8)) | (__v_209.as_canonical_u64() << 16)) | (__v_210.as_canonical_u64() << 24)) + u128::from((((__v_235.as_canonical_u64() << 0) | (__v_236.as_canonical_u64() << 8)) | (__v_237.as_canonical_u64() << 16)) | (__v_234.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_238: G = G::from_u8(__u32_bytes[0]); let __v_239: G = G::from_u8(__u32_bytes[1]); let __v_240: G = G::from_u8(__u32_bytes[2]); let __v_241: G = G::from_u8(__u32_bytes[3]); let __v_242: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_238; let __vj = __v_239; 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_240; let __vj = __v_241; 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_243: G = __v_242 * __v_242; if (__v_243 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_221, &__v_238) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_244: G = __b2_out.0; let __v_245: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_222, &__v_239) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_246: G = __b2_out.0; let __v_247: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_223, &__v_240) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_248: G = __b2_out.0; let __v_249: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_224, &__v_241) } else { aiur::execute::bytes2_xor_split7_value(__v_224, __v_241, record) }; let __v_250: G = __b2_out.0; let __v_251: G = __b2_out.1; let __v_252: G = __v_244 + __v_247; let __v_253: G = __v_246 + __v_249; let __v_254: G = __v_248 + __v_251; let __v_255: G = __v_250 + __v_245; let __u32_sum: u128 = (u128::from((((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8)) | (__v_11.as_canonical_u64() << 16)) | (__v_12.as_canonical_u64() << 24)) + u128::from((((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8)) | (__v_27.as_canonical_u64() << 16)) | (__v_28.as_canonical_u64() << 24))) + u128::from((((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8)) | (__v_83.as_canonical_u64() << 16)) | (__v_84.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_256: G = G::from_u8(__u32_bytes[0]); let __v_257: G = G::from_u8(__u32_bytes[1]); let __v_258: G = G::from_u8(__u32_bytes[2]); let __v_259: G = G::from_u8(__u32_bytes[3]); let __v_260: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_256; let __vj = __v_257; 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_258; let __vj = __v_259; 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_261: G = __v_260 - __v_134; let __v_262: G = __v_260 - __v_136; let __v_263: G = __v_261 * __v_262; let __v_264: G = __v_260 * __v_263; if (__v_264 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_57, &__v_256) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_58, &__v_257) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_59, &__v_258) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __v_268: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_60, &__v_259) } else { aiur::execute::bytes2_xor_value(__v_60, __v_259, record) }; let __u32_sum: u128 = u128::from((((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8)) | (__v_43.as_canonical_u64() << 16)) | (__v_44.as_canonical_u64() << 24)) + u128::from((((__v_267.as_canonical_u64() << 0) | (__v_268.as_canonical_u64() << 8)) | (__v_265.as_canonical_u64() << 16)) | (__v_266.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_269: G = G::from_u8(__u32_bytes[0]); let __v_270: G = G::from_u8(__u32_bytes[1]); let __v_271: G = G::from_u8(__u32_bytes[2]); let __v_272: G = G::from_u8(__u32_bytes[3]); let __v_273: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_269; let __vj = __v_270; 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_271; let __vj = __v_272; 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_274: G = __v_273 * __v_273; if (__v_274 != __v_273) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_273.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_25, &__v_269) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_275: G = __b2_out.0; let __v_276: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_26, &__v_270) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_277: G = __b2_out.0; let __v_278: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_27, &__v_271) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_279: G = __b2_out.0; let __v_280: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_28, &__v_272) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_272, record) }; let __v_281: G = __b2_out.0; let __v_282: G = __b2_out.1; let __v_283: G = __v_277 + __v_280; let __v_284: G = __v_279 + __v_282; let __v_285: G = __v_281 + __v_276; let __v_286: G = __v_275 + __v_278; let __u32_sum: u128 = (u128::from((((__v_256.as_canonical_u64() << 0) | (__v_257.as_canonical_u64() << 8)) | (__v_258.as_canonical_u64() << 16)) | (__v_259.as_canonical_u64() << 24)) + u128::from((((__v_283.as_canonical_u64() << 0) | (__v_284.as_canonical_u64() << 8)) | (__v_285.as_canonical_u64() << 16)) | (__v_286.as_canonical_u64() << 24))) + u128::from((((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8)) | (__v_87.as_canonical_u64() << 16)) | (__v_88.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_287: G = G::from_u8(__u32_bytes[0]); let __v_288: G = G::from_u8(__u32_bytes[1]); let __v_289: G = G::from_u8(__u32_bytes[2]); let __v_290: G = G::from_u8(__u32_bytes[3]); let __v_291: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_287; let __vj = __v_288; 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_289; let __vj = __v_290; 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_292: G = __v_291 - __v_134; let __v_293: G = __v_291 - __v_136; let __v_294: G = __v_292 * __v_293; let __v_295: G = __v_291 * __v_294; if (__v_295 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_295.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_267, &__v_287) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_268, &__v_288) } else { aiur::execute::bytes2_xor_value(__v_268, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_265, &__v_289) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __v_299: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_266, &__v_290) } else { aiur::execute::bytes2_xor_value(__v_266, __v_290, record) }; let __u32_sum: u128 = u128::from((((__v_269.as_canonical_u64() << 0) | (__v_270.as_canonical_u64() << 8)) | (__v_271.as_canonical_u64() << 16)) | (__v_272.as_canonical_u64() << 24)) + u128::from((((__v_297.as_canonical_u64() << 0) | (__v_298.as_canonical_u64() << 8)) | (__v_299.as_canonical_u64() << 16)) | (__v_296.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_300: G = G::from_u8(__u32_bytes[0]); let __v_301: G = G::from_u8(__u32_bytes[1]); let __v_302: G = G::from_u8(__u32_bytes[2]); let __v_303: G = G::from_u8(__u32_bytes[3]); let __v_304: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_300; let __vj = __v_301; 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_302; let __vj = __v_303; 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_305: G = __v_304 * __v_304; if (__v_305 != __v_304) { return Err(ExecError::AssertEqMismatch { lhs: __v_305.as_canonical_u64(), rhs: __v_304.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_283, &__v_300) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_306: G = __b2_out.0; let __v_307: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_284, &__v_301) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_308: G = __b2_out.0; let __v_309: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_285, &__v_302) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_310: G = __b2_out.0; let __v_311: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_286, &__v_303) } else { aiur::execute::bytes2_xor_split7_value(__v_286, __v_303, record) }; let __v_312: G = __b2_out.0; let __v_313: G = __b2_out.1; let __v_314: G = __v_306 + __v_309; let __v_315: G = __v_308 + __v_311; let __v_316: G = __v_310 + __v_313; let __v_317: G = __v_312 + __v_307; let __u32_sum: u128 = (u128::from((((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8)) | (__v_15.as_canonical_u64() << 16)) | (__v_16.as_canonical_u64() << 24)) + u128::from((((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8)) | (__v_31.as_canonical_u64() << 16)) | (__v_32.as_canonical_u64() << 24))) + u128::from((((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8)) | (__v_91.as_canonical_u64() << 16)) | (__v_92.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_318: G = G::from_u8(__u32_bytes[0]); let __v_319: G = G::from_u8(__u32_bytes[1]); let __v_320: G = G::from_u8(__u32_bytes[2]); let __v_321: G = G::from_u8(__u32_bytes[3]); let __v_322: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_318; let __vj = __v_319; 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_320; let __vj = __v_321; 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_323: G = __v_322 - __v_134; let __v_324: G = __v_322 - __v_136; let __v_325: G = __v_323 * __v_324; let __v_326: G = __v_322 * __v_325; if (__v_326 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_61, &__v_318) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_62, &__v_319) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_63, &__v_320) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __v_330: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_64, &__v_321) } else { aiur::execute::bytes2_xor_value(__v_64, __v_321, record) }; let __u32_sum: u128 = u128::from((((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8)) | (__v_47.as_canonical_u64() << 16)) | (__v_48.as_canonical_u64() << 24)) + u128::from((((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8)) | (__v_327.as_canonical_u64() << 16)) | (__v_328.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_331: G = G::from_u8(__u32_bytes[0]); let __v_332: G = G::from_u8(__u32_bytes[1]); let __v_333: G = G::from_u8(__u32_bytes[2]); let __v_334: G = G::from_u8(__u32_bytes[3]); let __v_335: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_331; let __vj = __v_332; 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_333; let __vj = __v_334; 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_336: G = __v_335 * __v_335; if (__v_336 != __v_335) { return Err(ExecError::AssertEqMismatch { lhs: __v_336.as_canonical_u64(), rhs: __v_335.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_29, &__v_331) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_337: G = __b2_out.0; let __v_338: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_30, &__v_332) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_339: G = __b2_out.0; let __v_340: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_31, &__v_333) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_341: G = __b2_out.0; let __v_342: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_32, &__v_334) } else { aiur::execute::bytes2_xor_split4_value(__v_32, __v_334, record) }; let __v_343: G = __b2_out.0; let __v_344: G = __b2_out.1; let __v_345: G = __v_339 + __v_342; let __v_346: G = __v_341 + __v_344; let __v_347: G = __v_343 + __v_338; let __v_348: G = __v_337 + __v_340; let __u32_sum: u128 = (u128::from((((__v_318.as_canonical_u64() << 0) | (__v_319.as_canonical_u64() << 8)) | (__v_320.as_canonical_u64() << 16)) | (__v_321.as_canonical_u64() << 24)) + u128::from((((__v_345.as_canonical_u64() << 0) | (__v_346.as_canonical_u64() << 8)) | (__v_347.as_canonical_u64() << 16)) | (__v_348.as_canonical_u64() << 24))) + u128::from((((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8)) | (__v_95.as_canonical_u64() << 16)) | (__v_96.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); let __v_350: G = G::from_u8(__u32_bytes[1]); let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_349; let __vj = __v_350; 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_351; let __vj = __v_352; 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_354: G = __v_353 - __v_134; let __v_355: G = __v_353 - __v_136; let __v_356: G = __v_354 * __v_355; let __v_357: G = __v_353 * __v_356; if (__v_357 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_329, &__v_349) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_330, &__v_350) } else { aiur::execute::bytes2_xor_value(__v_330, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_327, &__v_351) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __v_361: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_328, &__v_352) } else { aiur::execute::bytes2_xor_value(__v_328, __v_352, record) }; let __u32_sum: u128 = u128::from((((__v_331.as_canonical_u64() << 0) | (__v_332.as_canonical_u64() << 8)) | (__v_333.as_canonical_u64() << 16)) | (__v_334.as_canonical_u64() << 24)) + u128::from((((__v_359.as_canonical_u64() << 0) | (__v_360.as_canonical_u64() << 8)) | (__v_361.as_canonical_u64() << 16)) | (__v_358.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_362: G = G::from_u8(__u32_bytes[0]); let __v_363: G = G::from_u8(__u32_bytes[1]); let __v_364: G = G::from_u8(__u32_bytes[2]); let __v_365: G = G::from_u8(__u32_bytes[3]); let __v_366: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_362; let __vj = __v_363; 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_364; let __vj = __v_365; 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_367: G = __v_366 * __v_366; if (__v_367 != __v_366) { return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_366.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_345, &__v_362) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_368: G = __b2_out.0; let __v_369: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_346, &__v_363) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_370: G = __b2_out.0; let __v_371: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_347, &__v_364) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_372: G = __b2_out.0; let __v_373: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_348, &__v_365) } else { aiur::execute::bytes2_xor_split7_value(__v_348, __v_365, record) }; let __v_374: G = __b2_out.0; let __v_375: G = __b2_out.1; let __v_376: G = __v_368 + __v_371; let __v_377: G = __v_370 + __v_373; let __v_378: G = __v_372 + __v_375; let __v_379: G = __v_374 + __v_369; let __u32_sum: u128 = (u128::from((((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8)) | (__v_165.as_canonical_u64() << 16)) | (__v_166.as_canonical_u64() << 24)) + u128::from((((__v_252.as_canonical_u64() << 0) | (__v_253.as_canonical_u64() << 8)) | (__v_254.as_canonical_u64() << 16)) | (__v_255.as_canonical_u64() << 24))) + u128::from((((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8)) | (__v_99.as_canonical_u64() << 16)) | (__v_100.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_380: G = G::from_u8(__u32_bytes[0]); let __v_381: G = G::from_u8(__u32_bytes[1]); let __v_382: G = G::from_u8(__u32_bytes[2]); let __v_383: G = G::from_u8(__u32_bytes[3]); let __v_384: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_380; let __vj = __v_381; 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_382; let __vj = __v_383; 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_385: G = __v_384 - __v_134; let __v_386: G = __v_384 - __v_136; let __v_387: G = __v_385 * __v_386; let __v_388: G = __v_384 * __v_387; if (__v_388 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_359, &__v_380) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_360, &__v_381) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_361, &__v_382) } else { aiur::execute::bytes2_xor_value(__v_361, __v_382, record) }; let __v_392: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_358, &__v_383) } else { aiur::execute::bytes2_xor_value(__v_358, __v_383, record) }; let __u32_sum: u128 = u128::from((((__v_300.as_canonical_u64() << 0) | (__v_301.as_canonical_u64() << 8)) | (__v_302.as_canonical_u64() << 16)) | (__v_303.as_canonical_u64() << 24)) + u128::from((((__v_391.as_canonical_u64() << 0) | (__v_392.as_canonical_u64() << 8)) | (__v_389.as_canonical_u64() << 16)) | (__v_390.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_393: G = G::from_u8(__u32_bytes[0]); let __v_394: G = G::from_u8(__u32_bytes[1]); let __v_395: G = G::from_u8(__u32_bytes[2]); let __v_396: G = G::from_u8(__u32_bytes[3]); let __v_397: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_393; let __vj = __v_394; 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_395; let __vj = __v_396; 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_398: G = __v_397 * __v_397; if (__v_398 != __v_397) { return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_397.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_252, &__v_393) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_399: G = __b2_out.0; let __v_400: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_253, &__v_394) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_401: G = __b2_out.0; let __v_402: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_254, &__v_395) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_403: G = __b2_out.0; let __v_404: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_255, &__v_396) } else { aiur::execute::bytes2_xor_split4_value(__v_255, __v_396, record) }; let __v_405: G = __b2_out.0; let __v_406: G = __b2_out.1; let __v_407: G = __v_401 + __v_404; let __v_408: G = __v_403 + __v_406; let __v_409: G = __v_405 + __v_400; let __v_410: G = __v_399 + __v_402; let __u32_sum: u128 = (u128::from((((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8)) | (__v_382.as_canonical_u64() << 16)) | (__v_383.as_canonical_u64() << 24)) + u128::from((((__v_407.as_canonical_u64() << 0) | (__v_408.as_canonical_u64() << 8)) | (__v_409.as_canonical_u64() << 16)) | (__v_410.as_canonical_u64() << 24))) + u128::from((((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8)) | (__v_103.as_canonical_u64() << 16)) | (__v_104.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_411: G = G::from_u8(__u32_bytes[0]); let __v_412: G = G::from_u8(__u32_bytes[1]); let __v_413: G = G::from_u8(__u32_bytes[2]); let __v_414: G = G::from_u8(__u32_bytes[3]); let __v_415: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_411; let __vj = __v_412; 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_413; let __vj = __v_414; 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_416: G = __v_415 - __v_134; let __v_417: G = __v_415 - __v_136; let __v_418: G = __v_416 * __v_417; let __v_419: G = __v_415 * __v_418; if (__v_419 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_391, &__v_411) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_392, &__v_412) } else { aiur::execute::bytes2_xor_value(__v_392, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_389, &__v_413) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __v_423: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_390, &__v_414) } else { aiur::execute::bytes2_xor_value(__v_390, __v_414, record) }; let __u32_sum: u128 = u128::from((((__v_393.as_canonical_u64() << 0) | (__v_394.as_canonical_u64() << 8)) | (__v_395.as_canonical_u64() << 16)) | (__v_396.as_canonical_u64() << 24)) + u128::from((((__v_421.as_canonical_u64() << 0) | (__v_422.as_canonical_u64() << 8)) | (__v_423.as_canonical_u64() << 16)) | (__v_420.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_424: G = G::from_u8(__u32_bytes[0]); let __v_425: G = G::from_u8(__u32_bytes[1]); let __v_426: G = G::from_u8(__u32_bytes[2]); let __v_427: G = G::from_u8(__u32_bytes[3]); let __v_428: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_424; let __vj = __v_425; 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_426; let __vj = __v_427; 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_429: G = __v_428 * __v_428; if (__v_429 != __v_428) { return Err(ExecError::AssertEqMismatch { lhs: __v_429.as_canonical_u64(), rhs: __v_428.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_407, &__v_424) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_430: G = __b2_out.0; let __v_431: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_408, &__v_425) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_432: G = __b2_out.0; let __v_433: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_409, &__v_426) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_434: G = __b2_out.0; let __v_435: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_410, &__v_427) } else { aiur::execute::bytes2_xor_split7_value(__v_410, __v_427, record) }; let __v_436: G = __b2_out.0; let __v_437: G = __b2_out.1; let __v_438: G = __v_430 + __v_433; let __v_439: G = __v_432 + __v_435; let __v_440: G = __v_434 + __v_437; let __v_441: G = __v_436 + __v_431; let __u32_sum: u128 = (u128::from((((__v_225.as_canonical_u64() << 0) | (__v_226.as_canonical_u64() << 8)) | (__v_227.as_canonical_u64() << 16)) | (__v_228.as_canonical_u64() << 24)) + u128::from((((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8)) | (__v_316.as_canonical_u64() << 16)) | (__v_317.as_canonical_u64() << 24))) + u128::from((((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8)) | (__v_107.as_canonical_u64() << 16)) | (__v_108.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_442: G = G::from_u8(__u32_bytes[0]); let __v_443: G = G::from_u8(__u32_bytes[1]); let __v_444: G = G::from_u8(__u32_bytes[2]); let __v_445: G = G::from_u8(__u32_bytes[3]); let __v_446: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_442; let __vj = __v_443; 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_444; let __vj = __v_445; 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_447: G = __v_446 - __v_134; let __v_448: G = __v_446 - __v_136; let __v_449: G = __v_447 * __v_448; let __v_450: G = __v_446 * __v_449; if (__v_450 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_450.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_173, &__v_442) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_174, &__v_443) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_175, &__v_444) } else { aiur::execute::bytes2_xor_value(__v_175, __v_444, record) }; let __v_454: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_172, &__v_445) } else { aiur::execute::bytes2_xor_value(__v_172, __v_445, record) }; let __u32_sum: u128 = u128::from((((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8)) | (__v_364.as_canonical_u64() << 16)) | (__v_365.as_canonical_u64() << 24)) + u128::from((((__v_453.as_canonical_u64() << 0) | (__v_454.as_canonical_u64() << 8)) | (__v_451.as_canonical_u64() << 16)) | (__v_452.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_455: G = G::from_u8(__u32_bytes[0]); let __v_456: G = G::from_u8(__u32_bytes[1]); let __v_457: G = G::from_u8(__u32_bytes[2]); let __v_458: G = G::from_u8(__u32_bytes[3]); let __v_459: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_455; let __vj = __v_456; 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_457; let __vj = __v_458; 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_460: G = __v_459 * __v_459; if (__v_460 != __v_459) { return Err(ExecError::AssertEqMismatch { lhs: __v_460.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_314, &__v_455) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_315, &__v_456) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_316, &__v_457) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_465: G = __b2_out.0; let __v_466: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_317, &__v_458) } else { aiur::execute::bytes2_xor_split4_value(__v_317, __v_458, record) }; let __v_467: G = __b2_out.0; let __v_468: G = __b2_out.1; let __v_469: G = __v_463 + __v_466; let __v_470: G = __v_465 + __v_468; let __v_471: G = __v_467 + __v_462; let __v_472: G = __v_461 + __v_464; let __u32_sum: u128 = (u128::from((((__v_442.as_canonical_u64() << 0) | (__v_443.as_canonical_u64() << 8)) | (__v_444.as_canonical_u64() << 16)) | (__v_445.as_canonical_u64() << 24)) + u128::from((((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8)) | (__v_471.as_canonical_u64() << 16)) | (__v_472.as_canonical_u64() << 24))) + u128::from((((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8)) | (__v_111.as_canonical_u64() << 16)) | (__v_112.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_473: G = G::from_u8(__u32_bytes[0]); let __v_474: G = G::from_u8(__u32_bytes[1]); let __v_475: G = G::from_u8(__u32_bytes[2]); let __v_476: G = G::from_u8(__u32_bytes[3]); let __v_477: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_473; let __vj = __v_474; 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_475; let __vj = __v_476; 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_478: G = __v_477 - __v_134; let __v_479: G = __v_477 - __v_136; let __v_480: G = __v_478 * __v_479; let __v_481: G = __v_477 * __v_480; if (__v_481 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_481.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_453, &__v_473) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_454, &__v_474) } else { aiur::execute::bytes2_xor_value(__v_454, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_451, &__v_475) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __v_485: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_452, &__v_476) } else { aiur::execute::bytes2_xor_value(__v_452, __v_476, record) }; let __u32_sum: u128 = u128::from((((__v_455.as_canonical_u64() << 0) | (__v_456.as_canonical_u64() << 8)) | (__v_457.as_canonical_u64() << 16)) | (__v_458.as_canonical_u64() << 24)) + u128::from((((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8)) | (__v_485.as_canonical_u64() << 16)) | (__v_482.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_486: G = G::from_u8(__u32_bytes[0]); let __v_487: G = G::from_u8(__u32_bytes[1]); let __v_488: G = G::from_u8(__u32_bytes[2]); let __v_489: G = G::from_u8(__u32_bytes[3]); let __v_490: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_486; let __vj = __v_487; 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_488; let __vj = __v_489; 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_491: G = __v_490 * __v_490; if (__v_491 != __v_490) { return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_469, &__v_486) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_470, &__v_487) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_471, &__v_488) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_472, &__v_489) } else { aiur::execute::bytes2_xor_split7_value(__v_472, __v_489, record) }; let __v_498: G = __b2_out.0; let __v_499: G = __b2_out.1; let __v_500: G = __v_492 + __v_495; let __v_501: G = __v_494 + __v_497; let __v_502: G = __v_496 + __v_499; let __v_503: G = __v_498 + __v_493; let __u32_sum: u128 = (u128::from((((__v_287.as_canonical_u64() << 0) | (__v_288.as_canonical_u64() << 8)) | (__v_289.as_canonical_u64() << 16)) | (__v_290.as_canonical_u64() << 24)) + u128::from((((__v_376.as_canonical_u64() << 0) | (__v_377.as_canonical_u64() << 8)) | (__v_378.as_canonical_u64() << 16)) | (__v_379.as_canonical_u64() << 24))) + u128::from((((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8)) | (__v_115.as_canonical_u64() << 16)) | (__v_116.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_504: G = G::from_u8(__u32_bytes[0]); let __v_505: G = G::from_u8(__u32_bytes[1]); let __v_506: G = G::from_u8(__u32_bytes[2]); let __v_507: G = G::from_u8(__u32_bytes[3]); let __v_508: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_504; let __vj = __v_505; 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_506; let __vj = __v_507; 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_509: G = __v_508 - __v_134; let __v_510: G = __v_508 - __v_136; let __v_511: G = __v_509 * __v_510; let __v_512: G = __v_508 * __v_511; if (__v_512 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_235, &__v_504) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_236, &__v_505) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_237, &__v_506) } else { aiur::execute::bytes2_xor_value(__v_237, __v_506, record) }; let __v_516: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_234, &__v_507) } else { aiur::execute::bytes2_xor_value(__v_234, __v_507, record) }; let __u32_sum: u128 = u128::from((((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8)) | (__v_178.as_canonical_u64() << 16)) | (__v_179.as_canonical_u64() << 24)) + u128::from((((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8)) | (__v_513.as_canonical_u64() << 16)) | (__v_514.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_517: G = G::from_u8(__u32_bytes[0]); let __v_518: G = G::from_u8(__u32_bytes[1]); let __v_519: G = G::from_u8(__u32_bytes[2]); let __v_520: G = G::from_u8(__u32_bytes[3]); let __v_521: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_517; let __vj = __v_518; 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_519; let __vj = __v_520; 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_522: G = __v_521 * __v_521; if (__v_522 != __v_521) { return Err(ExecError::AssertEqMismatch { lhs: __v_522.as_canonical_u64(), rhs: __v_521.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_376, &__v_517) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_523: G = __b2_out.0; let __v_524: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_377, &__v_518) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_378, &__v_519) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_379, &__v_520) } else { aiur::execute::bytes2_xor_split4_value(__v_379, __v_520, record) }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; let __v_531: G = __v_525 + __v_528; let __v_532: G = __v_527 + __v_530; let __v_533: G = __v_529 + __v_524; let __v_534: G = __v_523 + __v_526; let __u32_sum: u128 = (u128::from((((__v_504.as_canonical_u64() << 0) | (__v_505.as_canonical_u64() << 8)) | (__v_506.as_canonical_u64() << 16)) | (__v_507.as_canonical_u64() << 24)) + u128::from((((__v_531.as_canonical_u64() << 0) | (__v_532.as_canonical_u64() << 8)) | (__v_533.as_canonical_u64() << 16)) | (__v_534.as_canonical_u64() << 24))) + u128::from((((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8)) | (__v_119.as_canonical_u64() << 16)) | (__v_120.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_535: G = G::from_u8(__u32_bytes[0]); let __v_536: G = G::from_u8(__u32_bytes[1]); let __v_537: G = G::from_u8(__u32_bytes[2]); let __v_538: G = G::from_u8(__u32_bytes[3]); let __v_539: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_535; let __vj = __v_536; 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_537; let __vj = __v_538; 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_540: G = __v_539 - __v_134; let __v_541: G = __v_539 - __v_136; let __v_542: G = __v_540 * __v_541; let __v_543: G = __v_539 * __v_542; if (__v_543 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_515, &__v_535) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_516, &__v_536) } else { aiur::execute::bytes2_xor_value(__v_516, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_513, &__v_537) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __v_547: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_514, &__v_538) } else { aiur::execute::bytes2_xor_value(__v_514, __v_538, record) }; let __u32_sum: u128 = u128::from((((__v_517.as_canonical_u64() << 0) | (__v_518.as_canonical_u64() << 8)) | (__v_519.as_canonical_u64() << 16)) | (__v_520.as_canonical_u64() << 24)) + u128::from((((__v_545.as_canonical_u64() << 0) | (__v_546.as_canonical_u64() << 8)) | (__v_547.as_canonical_u64() << 16)) | (__v_544.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_548: G = G::from_u8(__u32_bytes[0]); let __v_549: G = G::from_u8(__u32_bytes[1]); let __v_550: G = G::from_u8(__u32_bytes[2]); let __v_551: G = G::from_u8(__u32_bytes[3]); let __v_552: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_548; let __vj = __v_549; 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_550; let __vj = __v_551; 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_553: G = __v_552 * __v_552; if (__v_553 != __v_552) { return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_552.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_531, &__v_548) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_554: G = __b2_out.0; let __v_555: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_532, &__v_549) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_556: G = __b2_out.0; let __v_557: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_533, &__v_550) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_534, &__v_551) } else { aiur::execute::bytes2_xor_split7_value(__v_534, __v_551, record) }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; let __v_562: G = __v_554 + __v_557; let __v_563: G = __v_556 + __v_559; let __v_564: G = __v_558 + __v_561; let __v_565: G = __v_560 + __v_555; let __u32_sum: u128 = (u128::from((((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8)) | (__v_351.as_canonical_u64() << 16)) | (__v_352.as_canonical_u64() << 24)) + u128::from((((__v_190.as_canonical_u64() << 0) | (__v_191.as_canonical_u64() << 8)) | (__v_192.as_canonical_u64() << 16)) | (__v_193.as_canonical_u64() << 24))) + u128::from((((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8)) | (__v_123.as_canonical_u64() << 16)) | (__v_124.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_566: G = G::from_u8(__u32_bytes[0]); let __v_567: G = G::from_u8(__u32_bytes[1]); let __v_568: G = G::from_u8(__u32_bytes[2]); let __v_569: G = G::from_u8(__u32_bytes[3]); let __v_570: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_566; let __vj = __v_567; 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_568; let __vj = __v_569; 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_571: G = __v_570 - __v_134; let __v_572: G = __v_570 - __v_136; let __v_573: G = __v_571 * __v_572; let __v_574: G = __v_570 * __v_573; if (__v_574 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_574.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_297, &__v_566) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_298, &__v_567) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_299, &__v_568) } else { aiur::execute::bytes2_xor_value(__v_299, __v_568, record) }; let __v_578: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_296, &__v_569) } else { aiur::execute::bytes2_xor_value(__v_296, __v_569, record) }; let __u32_sum: u128 = u128::from((((__v_238.as_canonical_u64() << 0) | (__v_239.as_canonical_u64() << 8)) | (__v_240.as_canonical_u64() << 16)) | (__v_241.as_canonical_u64() << 24)) + u128::from((((__v_577.as_canonical_u64() << 0) | (__v_578.as_canonical_u64() << 8)) | (__v_575.as_canonical_u64() << 16)) | (__v_576.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_579: G = G::from_u8(__u32_bytes[0]); let __v_580: G = G::from_u8(__u32_bytes[1]); let __v_581: G = G::from_u8(__u32_bytes[2]); let __v_582: G = G::from_u8(__u32_bytes[3]); let __v_583: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_579; let __vj = __v_580; 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_581; let __vj = __v_582; 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_584: G = __v_583 * __v_583; if (__v_584 != __v_583) { return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_583.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_190, &__v_579) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_585: G = __b2_out.0; let __v_586: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_191, &__v_580) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_587: G = __b2_out.0; let __v_588: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_192, &__v_581) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_589: G = __b2_out.0; let __v_590: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_193, &__v_582) } else { aiur::execute::bytes2_xor_split4_value(__v_193, __v_582, record) }; let __v_591: G = __b2_out.0; let __v_592: G = __b2_out.1; let __v_593: G = __v_587 + __v_590; let __v_594: G = __v_589 + __v_592; let __v_595: G = __v_591 + __v_586; let __v_596: G = __v_585 + __v_588; let __u32_sum: u128 = (u128::from((((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8)) | (__v_568.as_canonical_u64() << 16)) | (__v_569.as_canonical_u64() << 24)) + u128::from((((__v_593.as_canonical_u64() << 0) | (__v_594.as_canonical_u64() << 8)) | (__v_595.as_canonical_u64() << 16)) | (__v_596.as_canonical_u64() << 24))) + u128::from((((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8)) | (__v_127.as_canonical_u64() << 16)) | (__v_128.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_597: G = G::from_u8(__u32_bytes[0]); let __v_598: G = G::from_u8(__u32_bytes[1]); let __v_599: G = G::from_u8(__u32_bytes[2]); let __v_600: G = G::from_u8(__u32_bytes[3]); let __v_601: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_597; let __vj = __v_598; 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_599; let __vj = __v_600; 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_602: G = __v_601 - __v_134; let __v_603: G = __v_601 - __v_136; let __v_604: G = __v_602 * __v_603; let __v_605: G = __v_601 * __v_604; if (__v_605 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_605.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_577, &__v_597) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_578, &__v_598) } else { aiur::execute::bytes2_xor_value(__v_578, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_575, &__v_599) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __v_609: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_576, &__v_600) } else { aiur::execute::bytes2_xor_value(__v_576, __v_600, record) }; let __u32_sum: u128 = u128::from((((__v_579.as_canonical_u64() << 0) | (__v_580.as_canonical_u64() << 8)) | (__v_581.as_canonical_u64() << 16)) | (__v_582.as_canonical_u64() << 24)) + u128::from((((__v_607.as_canonical_u64() << 0) | (__v_608.as_canonical_u64() << 8)) | (__v_609.as_canonical_u64() << 16)) | (__v_606.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_610: G = G::from_u8(__u32_bytes[0]); let __v_611: G = G::from_u8(__u32_bytes[1]); let __v_612: G = G::from_u8(__u32_bytes[2]); let __v_613: G = G::from_u8(__u32_bytes[3]); let __v_614: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_610; let __vj = __v_611; 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_612; let __vj = __v_613; 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_615: G = __v_614 * __v_614; if (__v_615 != __v_614) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_614.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_593, &__v_610) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_616: G = __b2_out.0; let __v_617: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_594, &__v_611) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_618: G = __b2_out.0; let __v_619: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_595, &__v_612) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_620: G = __b2_out.0; let __v_621: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_596, &__v_613) } else { aiur::execute::bytes2_xor_split7_value(__v_596, __v_613, record) }; let __v_622: G = __b2_out.0; let __v_623: G = __b2_out.1; let __v_624: G = __v_616 + __v_619; let __v_625: G = __v_618 + __v_621; let __v_626: G = __v_620 + __v_623; let __v_627: G = __v_622 + __v_617; let __v_628: G = __v_0 + __v_134; let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_628, __v_411, __v_412, __v_413, __v_414, __v_473, __v_474, __v_475, __v_476, __v_535, __v_536, __v_537, __v_538, __v_597, __v_598, __v_599, __v_600, __v_624, __v_625, __v_626, __v_627, __v_438, __v_439, __v_440, __v_441, __v_500, __v_501, __v_502, __v_503, __v_562, __v_563, __v_564, __v_565, __v_548, __v_549, __v_550, __v_551, __v_610, __v_611, __v_612, __v_613, __v_424, __v_425, __v_426, __v_427, __v_486, __v_487, __v_488, __v_489, __v_483, __v_484, __v_485, __v_482, __v_545, __v_546, __v_547, __v_544, __v_607, __v_608, __v_609, __v_606, __v_421, __v_422, __v_423, __v_420, __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 ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_629: G = __r_arr[0]; let __v_630: G = __r_arr[1]; let __v_631: G = __r_arr[2]; let __v_632: G = __r_arr[3]; let __v_633: G = __r_arr[4]; let __v_634: G = __r_arr[5]; let __v_635: G = __r_arr[6]; let __v_636: G = __r_arr[7]; let __v_637: G = __r_arr[8]; let __v_638: G = __r_arr[9]; let __v_639: G = __r_arr[10]; let __v_640: G = __r_arr[11]; let __v_641: G = __r_arr[12]; let __v_642: G = __r_arr[13]; let __v_643: G = __r_arr[14]; let __v_644: G = __r_arr[15]; let __v_645: G = __r_arr[16]; let __v_646: G = __r_arr[17]; let __v_647: G = __r_arr[18]; let __v_648: G = __r_arr[19]; let __v_649: G = __r_arr[20]; let __v_650: G = __r_arr[21]; let __v_651: G = __r_arr[22]; let __v_652: G = __r_arr[23]; let __v_653: G = __r_arr[24]; let __v_654: G = __r_arr[25]; let __v_655: G = __r_arr[26]; let __v_656: G = __r_arr[27]; let __v_657: G = __r_arr[28]; let __v_658: G = __r_arr[29]; let __v_659: G = __r_arr[30]; let __v_660: G = __r_arr[31]; let __ret: [G; OUT_83] = [__v_629, __v_630, __v_631, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660]; record.function_queries[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_84: usize = 1; const IN_84: usize = 1; const OUT_84: usize = 2; -fn aiur_fn_84(inp: [G; IN_84], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_84] = [__v_2, __v_3]; record.function_queries[84].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_84(inp: [G; IN_84], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_84] = [__v_2, __v_3]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_85: usize = 1; const IN_85: usize = 1; const OUT_85: usize = 2; -fn aiur_fn_85(inp: [G; IN_85], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_1, __v_2]; record.function_queries[85].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_85(inp: [G; IN_85], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_1, __v_2]; record.function_queries[85].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_86: usize = 1; const IN_86: usize = 1; const OUT_86: usize = 2; -fn aiur_fn_86(inp: [G; IN_86], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __ret: [G; OUT_86] = [__v_7, __v_4]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_86(inp: [G; IN_86], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = __v_5 * __v_3; let __v_7: G = __v_1 + __v_6; let __ret: [G; OUT_86] = [__v_7, __v_4]; record.function_queries[86].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_87: usize = 1; const IN_87: usize = 1; const OUT_87: usize = 10; -fn aiur_fn_87(inp: [G; IN_87], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __v_8: G = G::from_u64(0); let __ret: [G; OUT_87] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; record.function_queries[87].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_87(inp: [G; IN_87], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = __v_5 * __v_3; let __v_7: G = __v_1 + __v_6; let __v_8: G = G::from_u64(0); let __ret: [G; OUT_87] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; record.function_queries[87].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_88: usize = 1; const IN_88: usize = 1; const OUT_88: usize = 10; -fn aiur_fn_88(inp: [G; IN_88], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_3); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_5); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_7); let __v_15: G = (__v_12 + __v_14); let __v_16: G = (__v_10 + __v_15); let __v_17: G = (__v_1 + __v_16); let __v_18: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; record.function_queries[88].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_88(inp: [G; IN_88], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_3; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_5; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_7; let __v_15: G = __v_12 + __v_14; let __v_16: G = __v_10 + __v_15; let __v_17: G = __v_1 + __v_16; let __v_18: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; record.function_queries[88].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_89: usize = 1; const IN_89: usize = 1; const OUT_89: usize = 9; -fn aiur_fn_89(inp: [G; IN_89], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_89] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[89].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_89(inp: [G; IN_89], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_89] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[89].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_90: usize = 1; const IN_90: usize = 1; const OUT_90: usize = 2; -fn aiur_fn_90(inp: [G; IN_90], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = G::from_u64(256); let __v_11: G = (__v_10 * __v_2); let __v_12: G = G::from_u64(65536); let __v_13: G = (__v_12 * __v_3); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_4); let __v_16: G = G::from_u64(4294967296); let __v_17: G = (__v_16 * __v_5); let __v_18: G = G::from_u64(1099511627776); let __v_19: G = (__v_18 * __v_6); let __v_20: G = G::from_u64(281474976710656); let __v_21: G = (__v_20 * __v_7); let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = (__v_22 * __v_8); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_1 + __v_29); let __ret: [G; OUT_90] = [__v_30, __v_9]; record.function_queries[90].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_90(inp: [G; IN_90], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_2; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_3; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_4; let __v_16: G = G::from_u64(4294967296); let __v_17: G = __v_16 * __v_5; let __v_18: G = G::from_u64(1099511627776); let __v_19: G = __v_18 * __v_6; let __v_20: G = G::from_u64(281474976710656); let __v_21: G = __v_20 * __v_7; let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = __v_22 * __v_8; let __v_24: G = __v_21 + __v_23; let __v_25: G = __v_19 + __v_24; let __v_26: G = __v_17 + __v_25; let __v_27: G = __v_15 + __v_26; let __v_28: G = __v_13 + __v_27; let __v_29: G = __v_11 + __v_28; let __v_30: G = __v_1 + __v_29; let __ret: [G; OUT_90] = [__v_30, __v_9]; record.function_queries[90].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_91: usize = 1; const IN_91: usize = 1; const OUT_91: usize = 33; -fn aiur_fn_91(inp: [G; IN_91], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; 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]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_91] = [__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]; record.function_queries[91].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_91(inp: [G; IN_91], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; 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]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_91] = [__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]; record.function_queries[91].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_92: usize = 2; const IN_92: usize = 2; const OUT_92: usize = 2; -fn aiur_fn_92(inp: [G; IN_92], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_3, __v_0]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_44, __v_41]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_92(inp: [G; IN_92], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_3, __v_0]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_38: G = G::from_u64(1); let __v_39: G = __v_1 - __v_38; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_44, __v_41]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_93: usize = 3; const IN_93: usize = 3; const OUT_93: usize = 2; -fn aiur_fn_93(inp: [G; IN_93], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 6] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_4, __v_0]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(3); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(4); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(5); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(6); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(7); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_9: G = (__v_1 - __v_8); let __v_10: G = (__v_2 + __v_8); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(9); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_5, __v_13, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_15, __v_12]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_12, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_12, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_7, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_7, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_93(inp: [G; IN_93], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 6] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_4, __v_0]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(3); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(4); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(5); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(6); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(7); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_9: G = __v_1 - __v_8; let __v_10: G = __v_2 + __v_8; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(9); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_5, __v_13, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_15, __v_12]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_12, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_12, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_7, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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; 6] = [__v_12, __v_7, __v_7, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_94: usize = 2; const IN_94: usize = 2; const OUT_94: usize = 2; -fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_3, __v_0]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; 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_94] = { let __args: [G; IN_94] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_9, __v_7]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_3, __v_0]; record.function_queries[94].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; 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_94] = { let __args: [G; IN_94] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_9, __v_7]; record.function_queries[94].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_95: usize = 1; const IN_95: usize = 1; const OUT_95: usize = 3; -fn aiur_fn_95(inp: [G; IN_95], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_1, __v_5, __v_6]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_95(inp: [G; IN_95], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_1, __v_5, __v_6]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_96: usize = 2; const IN_96: usize = 2; const OUT_96: usize = 2; -fn aiur_fn_96(inp: [G; IN_96], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_3, __v_0]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; 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_96] = { let __args: [G; IN_96] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; 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_2, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_96(inp: [G; IN_96], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_3, __v_0]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; 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_96] = { let __args: [G; IN_96] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; 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_2, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_97: usize = 3; const IN_97: usize = 3; const OUT_97: usize = 1; -fn aiur_fn_97(inp: [G; IN_97], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_97] = [__v_3]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 - __v_3); let __v_5: G = (__v_2 - __v_3); let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_3 + __v_6); let __ret: [G; OUT_97] = [__v_7]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 - __v_3); let __v_5: G = (__v_1 - __v_3); let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_97(inp: [G; IN_97], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_97] = [__v_3]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 - __v_3; let __v_5: G = __v_2 - __v_3; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_97] = [__v_7]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 - __v_3; let __v_5: G = __v_1 - __v_3; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_98: usize = 1; const IN_98: usize = 1; const OUT_98: usize = 66; -fn aiur_fn_98(inp: [G; IN_98], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_44, __v_43, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_49, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_53, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_52, __v_45, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_bool((__v_56 == G::ZERO)); let __v_58: G = (__v_56 + __v_57); let __v_59: G = (__v_58 + __v_58); let __v_60: G = (__v_48 + __v_59); let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_61: G = G::from_u8(__gb[0]); let __v_62: G = G::from_u8(__gb[1]); let __v_63: G = G::from_u8(__gb[2]); let __v_64: G = G::from_u8(__gb[3]); let __v_65: G = G::from_u8(__gb[4]); let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_61; let __vj = __v_62; 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_63; let __vj = __v_64; 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_65; let __vj = __v_66; 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_67; let __vj = __v_68; 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_69: G = G::from_u64(256); let __v_70: G = (__v_69 * __v_62); let __v_71: G = G::from_u64(65536); let __v_72: G = (__v_71 * __v_63); let __v_73: G = G::from_u64(16777216); let __v_74: G = (__v_73 * __v_64); let __v_75: G = G::from_u64(4294967296); let __v_76: G = (__v_75 * __v_65); let __v_77: G = G::from_u64(1099511627776); let __v_78: G = (__v_77 * __v_66); let __v_79: G = G::from_u64(281474976710656); let __v_80: G = (__v_79 * __v_67); let __v_81: G = G::from_u64(72057594037927936); let __v_82: G = (__v_81 * __v_68); let __v_83: G = (__v_80 + __v_82); let __v_84: G = (__v_78 + __v_83); let __v_85: G = (__v_76 + __v_84); let __v_86: G = (__v_74 + __v_85); let __v_87: G = (__v_72 + __v_86); let __v_88: G = (__v_70 + __v_87); let __v_89: G = (__v_61 + __v_88); if (__v_89 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_90: G = G::from_u64(1020); let __v_91: G = (__v_68 - __v_90); let __v_92: G = (__v_67 + __v_91); let __v_93: G = (__v_66 + __v_92); let __v_94: G = (__v_65 + __v_93); let __v_95: G = G::from_bool((__v_94 == G::ZERO)); let __v_96: G = (__v_63 + __v_64); let __v_97: G = (__v_62 + __v_96); let __v_98: G = (__v_61 + __v_97); let __v_99: G = G::from_bool((__v_98 == G::ZERO)); let __v_100: G = G::from_u64(1); let __v_101: G = (__v_100 - __v_99); let __v_102: G = (__v_95 * __v_101); let __v_103: G = (__v_100 - __v_102); if (__v_103 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_59.as_canonical_u64().to_le_bytes(); let __v_104: G = G::from_u8(__gb[0]); let __v_105: G = G::from_u8(__gb[1]); let __v_106: G = G::from_u8(__gb[2]); let __v_107: G = G::from_u8(__gb[3]); let __v_108: G = G::from_u8(__gb[4]); let __v_109: G = G::from_u8(__gb[5]); let __v_110: G = G::from_u8(__gb[6]); let __v_111: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_104; let __vj = __v_105; 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_106; let __vj = __v_107; 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_108; let __vj = __v_109; 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_110; let __vj = __v_111; 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_112: G = (__v_69 * __v_105); let __v_113: G = (__v_71 * __v_106); let __v_114: G = (__v_73 * __v_107); let __v_115: G = (__v_75 * __v_108); let __v_116: G = (__v_77 * __v_109); let __v_117: G = (__v_79 * __v_110); let __v_118: G = (__v_81 * __v_111); let __v_119: G = (__v_117 + __v_118); let __v_120: G = (__v_116 + __v_119); let __v_121: G = (__v_115 + __v_120); let __v_122: G = (__v_114 + __v_121); let __v_123: G = (__v_113 + __v_122); let __v_124: G = (__v_112 + __v_123); let __v_125: G = (__v_104 + __v_124); if (__v_125 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_111 - __v_90); let __v_127: G = (__v_110 + __v_126); let __v_128: G = (__v_109 + __v_127); let __v_129: G = (__v_108 + __v_128); let __v_130: G = G::from_bool((__v_129 == G::ZERO)); let __v_131: G = (__v_106 + __v_107); let __v_132: G = (__v_105 + __v_131); let __v_133: G = (__v_104 + __v_132); let __v_134: G = G::from_bool((__v_133 == G::ZERO)); let __v_135: G = (__v_100 - __v_134); let __v_136: G = (__v_130 * __v_135); let __v_137: G = (__v_100 - __v_136); if (__v_137 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_137.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes(); let __v_138: G = G::from_u8(__gb[0]); let __v_139: G = G::from_u8(__gb[1]); let __v_140: G = G::from_u8(__gb[2]); let __v_141: G = G::from_u8(__gb[3]); let __v_142: G = G::from_u8(__gb[4]); let __v_143: G = G::from_u8(__gb[5]); let __v_144: G = G::from_u8(__gb[6]); let __v_145: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_138; let __vj = __v_139; 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_140; let __vj = __v_141; 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_142; let __vj = __v_143; 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_144; let __vj = __v_145; 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_146: G = (__v_69 * __v_139); let __v_147: G = (__v_71 * __v_140); let __v_148: G = (__v_73 * __v_141); let __v_149: G = (__v_75 * __v_142); let __v_150: G = (__v_77 * __v_143); let __v_151: G = (__v_79 * __v_144); let __v_152: G = (__v_81 * __v_145); let __v_153: G = (__v_151 + __v_152); let __v_154: G = (__v_150 + __v_153); let __v_155: G = (__v_149 + __v_154); let __v_156: G = (__v_148 + __v_155); let __v_157: G = (__v_147 + __v_156); let __v_158: G = (__v_146 + __v_157); let __v_159: G = (__v_138 + __v_158); if (__v_159 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __v_160: G = (__v_145 - __v_90); let __v_161: G = (__v_144 + __v_160); let __v_162: G = (__v_143 + __v_161); let __v_163: G = (__v_142 + __v_162); let __v_164: G = G::from_bool((__v_163 == G::ZERO)); let __v_165: G = (__v_140 + __v_141); let __v_166: G = (__v_139 + __v_165); let __v_167: G = (__v_138 + __v_166); let __v_168: G = G::from_bool((__v_167 == G::ZERO)); let __v_169: G = (__v_100 - __v_168); let __v_170: G = (__v_164 * __v_169); let __v_171: G = (__v_100 - __v_170); if (__v_171 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_98] = [__v_46, __v_43, __v_50, __v_31, __v_54, __v_41, __v_1, __v_11, __v_59, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_55]; record.function_queries[98].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_98(inp: [G; IN_98], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_44, __v_43, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_49, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_53, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_52, __v_45, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_bool(__v_56 == G::ZERO); let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_58 + __v_58; let __v_60: G = __v_48 + __v_59; let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_61: G = G::from_u8(__gb[0]); let __v_62: G = G::from_u8(__gb[1]); let __v_63: G = G::from_u8(__gb[2]); let __v_64: G = G::from_u8(__gb[3]); let __v_65: G = G::from_u8(__gb[4]); let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_61; let __vj = __v_62; 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_63; let __vj = __v_64; 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_65; let __vj = __v_66; 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_67; let __vj = __v_68; 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_69: G = G::from_u64(256); let __v_70: G = __v_69 * __v_62; let __v_71: G = G::from_u64(65536); let __v_72: G = __v_71 * __v_63; let __v_73: G = G::from_u64(16777216); let __v_74: G = __v_73 * __v_64; let __v_75: G = G::from_u64(4294967296); let __v_76: G = __v_75 * __v_65; let __v_77: G = G::from_u64(1099511627776); let __v_78: G = __v_77 * __v_66; let __v_79: G = G::from_u64(281474976710656); let __v_80: G = __v_79 * __v_67; let __v_81: G = G::from_u64(72057594037927936); let __v_82: G = __v_81 * __v_68; let __v_83: G = __v_80 + __v_82; let __v_84: G = __v_78 + __v_83; let __v_85: G = __v_76 + __v_84; let __v_86: G = __v_74 + __v_85; let __v_87: G = __v_72 + __v_86; let __v_88: G = __v_70 + __v_87; let __v_89: G = __v_61 + __v_88; if (__v_89 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_90: G = G::from_u64(1020); let __v_91: G = __v_68 - __v_90; let __v_92: G = __v_67 + __v_91; let __v_93: G = __v_66 + __v_92; let __v_94: G = __v_65 + __v_93; let __v_95: G = G::from_bool(__v_94 == G::ZERO); let __v_96: G = __v_63 + __v_64; let __v_97: G = __v_62 + __v_96; let __v_98: G = __v_61 + __v_97; let __v_99: G = G::from_bool(__v_98 == G::ZERO); let __v_100: G = G::from_u64(1); let __v_101: G = __v_100 - __v_99; let __v_102: G = __v_95 * __v_101; let __v_103: G = __v_100 - __v_102; if (__v_103 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_59.as_canonical_u64().to_le_bytes(); let __v_104: G = G::from_u8(__gb[0]); let __v_105: G = G::from_u8(__gb[1]); let __v_106: G = G::from_u8(__gb[2]); let __v_107: G = G::from_u8(__gb[3]); let __v_108: G = G::from_u8(__gb[4]); let __v_109: G = G::from_u8(__gb[5]); let __v_110: G = G::from_u8(__gb[6]); let __v_111: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_104; let __vj = __v_105; 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_106; let __vj = __v_107; 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_108; let __vj = __v_109; 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_110; let __vj = __v_111; 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_112: G = __v_69 * __v_105; let __v_113: G = __v_71 * __v_106; let __v_114: G = __v_73 * __v_107; let __v_115: G = __v_75 * __v_108; let __v_116: G = __v_77 * __v_109; let __v_117: G = __v_79 * __v_110; let __v_118: G = __v_81 * __v_111; let __v_119: G = __v_117 + __v_118; let __v_120: G = __v_116 + __v_119; let __v_121: G = __v_115 + __v_120; let __v_122: G = __v_114 + __v_121; let __v_123: G = __v_113 + __v_122; let __v_124: G = __v_112 + __v_123; let __v_125: G = __v_104 + __v_124; if (__v_125 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None }); } let __v_126: G = __v_111 - __v_90; let __v_127: G = __v_110 + __v_126; let __v_128: G = __v_109 + __v_127; let __v_129: G = __v_108 + __v_128; let __v_130: G = G::from_bool(__v_129 == G::ZERO); let __v_131: G = __v_106 + __v_107; let __v_132: G = __v_105 + __v_131; let __v_133: G = __v_104 + __v_132; let __v_134: G = G::from_bool(__v_133 == G::ZERO); let __v_135: G = __v_100 - __v_134; let __v_136: G = __v_130 * __v_135; let __v_137: G = __v_100 - __v_136; if (__v_137 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_137.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes(); let __v_138: G = G::from_u8(__gb[0]); let __v_139: G = G::from_u8(__gb[1]); let __v_140: G = G::from_u8(__gb[2]); let __v_141: G = G::from_u8(__gb[3]); let __v_142: G = G::from_u8(__gb[4]); let __v_143: G = G::from_u8(__gb[5]); let __v_144: G = G::from_u8(__gb[6]); let __v_145: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_138; let __vj = __v_139; 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_140; let __vj = __v_141; 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_142; let __vj = __v_143; 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_144; let __vj = __v_145; 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_146: G = __v_69 * __v_139; let __v_147: G = __v_71 * __v_140; let __v_148: G = __v_73 * __v_141; let __v_149: G = __v_75 * __v_142; let __v_150: G = __v_77 * __v_143; let __v_151: G = __v_79 * __v_144; let __v_152: G = __v_81 * __v_145; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_150 + __v_153; let __v_155: G = __v_149 + __v_154; let __v_156: G = __v_148 + __v_155; let __v_157: G = __v_147 + __v_156; let __v_158: G = __v_146 + __v_157; let __v_159: G = __v_138 + __v_158; if (__v_159 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __v_160: G = __v_145 - __v_90; let __v_161: G = __v_144 + __v_160; let __v_162: G = __v_143 + __v_161; let __v_163: G = __v_142 + __v_162; let __v_164: G = G::from_bool(__v_163 == G::ZERO); let __v_165: G = __v_140 + __v_141; let __v_166: G = __v_139 + __v_165; let __v_167: G = __v_138 + __v_166; let __v_168: G = G::from_bool(__v_167 == G::ZERO); let __v_169: G = __v_100 - __v_168; let __v_170: G = __v_164 * __v_169; let __v_171: G = __v_100 - __v_170; if (__v_171 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_98] = [__v_46, __v_43, __v_50, __v_31, __v_54, __v_41, __v_1, __v_11, __v_59, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_55]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_99: usize = 57; const IN_99: usize = 57; const OUT_99: usize = 1; -fn aiur_fn_99(inp: [G; IN_99], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 10] = [__v_57, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 10] = [__v_57, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 10] = [__v_57, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_59]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 10] = [__v_57, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_60]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 10] = [__v_57, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_61]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 10] = [__v_57, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_62]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_63]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_64]; record.function_queries[99].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_99(inp: [G; IN_99], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 10] = [__v_57, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 10] = [__v_57, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 10] = [__v_57, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_59]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 10] = [__v_57, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_60]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 10] = [__v_57, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_61]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 10] = [__v_57, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_62]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_63]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_64]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_100: usize = 2; const IN_100: usize = 2; const OUT_100: usize = 3; -fn aiur_fn_100(inp: [G; IN_100], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_4: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_3, __v_4, __v_0]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; let __v_35: G = __r_arr[3]; let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = __r_arr[6]; let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_45, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_50, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_54, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_53, __v_46, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_bool((__v_57 == G::ZERO)); let __v_59: G = (__v_57 + __v_58); let __v_60: G = (__v_59 + __v_59); let __v_61: G = (__v_49 + __v_60); let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes(); let __v_62: G = G::from_u8(__gb[0]); let __v_63: G = G::from_u8(__gb[1]); let __v_64: G = G::from_u8(__gb[2]); let __v_65: G = G::from_u8(__gb[3]); let __v_66: G = G::from_u8(__gb[4]); let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_66; let __vj = __v_67; 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_68; let __vj = __v_69; 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_70: G = G::from_u64(256); let __v_71: G = (__v_70 * __v_63); let __v_72: G = G::from_u64(65536); let __v_73: G = (__v_72 * __v_64); let __v_74: G = G::from_u64(16777216); let __v_75: G = (__v_74 * __v_65); let __v_76: G = G::from_u64(4294967296); let __v_77: G = (__v_76 * __v_66); let __v_78: G = G::from_u64(1099511627776); let __v_79: G = (__v_78 * __v_67); let __v_80: G = G::from_u64(281474976710656); let __v_81: G = (__v_80 * __v_68); let __v_82: G = G::from_u64(72057594037927936); let __v_83: G = (__v_82 * __v_69); let __v_84: G = (__v_81 + __v_83); let __v_85: G = (__v_79 + __v_84); let __v_86: G = (__v_77 + __v_85); let __v_87: G = (__v_75 + __v_86); let __v_88: G = (__v_73 + __v_87); let __v_89: G = (__v_71 + __v_88); let __v_90: G = (__v_62 + __v_89); if (__v_90 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None }); } let __v_91: G = G::from_u64(1020); let __v_92: G = (__v_69 - __v_91); let __v_93: G = (__v_68 + __v_92); let __v_94: G = (__v_67 + __v_93); let __v_95: G = (__v_66 + __v_94); let __v_96: G = G::from_bool((__v_95 == G::ZERO)); let __v_97: G = (__v_64 + __v_65); let __v_98: G = (__v_63 + __v_97); let __v_99: G = (__v_62 + __v_98); let __v_100: G = G::from_bool((__v_99 == G::ZERO)); let __v_101: G = G::from_u64(1); let __v_102: G = (__v_101 - __v_100); let __v_103: G = (__v_96 * __v_102); let __v_104: G = (__v_101 - __v_103); if (__v_104 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_105: G = G::from_u8(__gb[0]); let __v_106: G = G::from_u8(__gb[1]); let __v_107: G = G::from_u8(__gb[2]); let __v_108: G = G::from_u8(__gb[3]); let __v_109: G = G::from_u8(__gb[4]); let __v_110: G = G::from_u8(__gb[5]); let __v_111: G = G::from_u8(__gb[6]); let __v_112: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_105; let __vj = __v_106; 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_107; let __vj = __v_108; 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_109; let __vj = __v_110; 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_111; let __vj = __v_112; 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_113: G = (__v_70 * __v_106); let __v_114: G = (__v_72 * __v_107); let __v_115: G = (__v_74 * __v_108); let __v_116: G = (__v_76 * __v_109); let __v_117: G = (__v_78 * __v_110); let __v_118: G = (__v_80 * __v_111); let __v_119: G = (__v_82 * __v_112); let __v_120: G = (__v_118 + __v_119); let __v_121: G = (__v_117 + __v_120); let __v_122: G = (__v_116 + __v_121); let __v_123: G = (__v_115 + __v_122); let __v_124: G = (__v_114 + __v_123); let __v_125: G = (__v_113 + __v_124); let __v_126: G = (__v_105 + __v_125); if (__v_126 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_127: G = (__v_112 - __v_91); let __v_128: G = (__v_111 + __v_127); let __v_129: G = (__v_110 + __v_128); let __v_130: G = (__v_109 + __v_129); let __v_131: G = G::from_bool((__v_130 == G::ZERO)); let __v_132: G = (__v_107 + __v_108); let __v_133: G = (__v_106 + __v_132); let __v_134: G = (__v_105 + __v_133); let __v_135: G = G::from_bool((__v_134 == G::ZERO)); let __v_136: G = (__v_101 - __v_135); let __v_137: G = (__v_131 * __v_136); let __v_138: G = (__v_101 - __v_137); if (__v_138 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes(); let __v_139: G = G::from_u8(__gb[0]); let __v_140: G = G::from_u8(__gb[1]); let __v_141: G = G::from_u8(__gb[2]); let __v_142: G = G::from_u8(__gb[3]); let __v_143: G = G::from_u8(__gb[4]); let __v_144: G = G::from_u8(__gb[5]); let __v_145: G = G::from_u8(__gb[6]); let __v_146: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_139; let __vj = __v_140; 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_141; let __vj = __v_142; 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_143; let __vj = __v_144; 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_145; let __vj = __v_146; 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_147: G = (__v_70 * __v_140); let __v_148: G = (__v_72 * __v_141); let __v_149: G = (__v_74 * __v_142); let __v_150: G = (__v_76 * __v_143); let __v_151: G = (__v_78 * __v_144); let __v_152: G = (__v_80 * __v_145); let __v_153: G = (__v_82 * __v_146); let __v_154: G = (__v_152 + __v_153); let __v_155: G = (__v_151 + __v_154); let __v_156: G = (__v_150 + __v_155); let __v_157: G = (__v_149 + __v_156); let __v_158: G = (__v_148 + __v_157); let __v_159: G = (__v_147 + __v_158); let __v_160: G = (__v_139 + __v_159); if (__v_160 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_161: G = (__v_146 - __v_91); let __v_162: G = (__v_145 + __v_161); let __v_163: G = (__v_144 + __v_162); let __v_164: G = (__v_143 + __v_163); let __v_165: G = G::from_bool((__v_164 == G::ZERO)); let __v_166: G = (__v_141 + __v_142); let __v_167: G = (__v_140 + __v_166); let __v_168: G = (__v_139 + __v_167); let __v_169: G = G::from_bool((__v_168 == G::ZERO)); let __v_170: G = (__v_101 - __v_169); let __v_171: G = (__v_165 * __v_170); let __v_172: G = (__v_101 - __v_171); if (__v_172 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __v_173: G = (__v_1 - __v_101); let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __v_176: G = __r_arr[2]; let __v_177: G = { let __values: [G; 11] = [__v_46, __v_47, __v_44, __v_51, __v_32, __v_55, __v_42, __v_2, __v_12, __v_60, __v_174]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_178: G = { let __values: [G; 10] = [__v_46, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_175]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_179: G = { let __values: [G; 10] = [__v_46, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_178]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_180: G = { let __values: [G; 10] = [__v_46, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_179]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_181: G = { let __values: [G; 10] = [__v_46, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_180]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_182: G = { let __values: [G; 10] = [__v_46, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_181]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_183: G = { let __values: [G; 10] = [__v_46, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_182]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_184: G = { let __values: [G; 10] = [__v_46, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_183]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_177, __v_184, __v_176]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_100(inp: [G; IN_100], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_4: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_3, __v_4, __v_0]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; let __v_35: G = __r_arr[3]; let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = __r_arr[6]; let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_45, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_50, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_54, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_53, __v_46, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_bool(__v_57 == G::ZERO); let __v_59: G = __v_57 + __v_58; let __v_60: G = __v_59 + __v_59; let __v_61: G = __v_49 + __v_60; let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes(); let __v_62: G = G::from_u8(__gb[0]); let __v_63: G = G::from_u8(__gb[1]); let __v_64: G = G::from_u8(__gb[2]); let __v_65: G = G::from_u8(__gb[3]); let __v_66: G = G::from_u8(__gb[4]); let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); 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); } if (!unconstrained) { let __vi = __v_66; let __vj = __v_67; 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_68; let __vj = __v_69; 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_70: G = G::from_u64(256); let __v_71: G = __v_70 * __v_63; let __v_72: G = G::from_u64(65536); let __v_73: G = __v_72 * __v_64; let __v_74: G = G::from_u64(16777216); let __v_75: G = __v_74 * __v_65; let __v_76: G = G::from_u64(4294967296); let __v_77: G = __v_76 * __v_66; let __v_78: G = G::from_u64(1099511627776); let __v_79: G = __v_78 * __v_67; let __v_80: G = G::from_u64(281474976710656); let __v_81: G = __v_80 * __v_68; let __v_82: G = G::from_u64(72057594037927936); let __v_83: G = __v_82 * __v_69; let __v_84: G = __v_81 + __v_83; let __v_85: G = __v_79 + __v_84; let __v_86: G = __v_77 + __v_85; let __v_87: G = __v_75 + __v_86; let __v_88: G = __v_73 + __v_87; let __v_89: G = __v_71 + __v_88; let __v_90: G = __v_62 + __v_89; if (__v_90 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None }); } let __v_91: G = G::from_u64(1020); let __v_92: G = __v_69 - __v_91; let __v_93: G = __v_68 + __v_92; let __v_94: G = __v_67 + __v_93; let __v_95: G = __v_66 + __v_94; let __v_96: G = G::from_bool(__v_95 == G::ZERO); let __v_97: G = __v_64 + __v_65; let __v_98: G = __v_63 + __v_97; let __v_99: G = __v_62 + __v_98; let __v_100: G = G::from_bool(__v_99 == G::ZERO); let __v_101: G = G::from_u64(1); let __v_102: G = __v_101 - __v_100; let __v_103: G = __v_96 * __v_102; let __v_104: G = __v_101 - __v_103; if (__v_104 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_105: G = G::from_u8(__gb[0]); let __v_106: G = G::from_u8(__gb[1]); let __v_107: G = G::from_u8(__gb[2]); let __v_108: G = G::from_u8(__gb[3]); let __v_109: G = G::from_u8(__gb[4]); let __v_110: G = G::from_u8(__gb[5]); let __v_111: G = G::from_u8(__gb[6]); let __v_112: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_105; let __vj = __v_106; 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_107; let __vj = __v_108; 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_109; let __vj = __v_110; 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_111; let __vj = __v_112; 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_113: G = __v_70 * __v_106; let __v_114: G = __v_72 * __v_107; let __v_115: G = __v_74 * __v_108; let __v_116: G = __v_76 * __v_109; let __v_117: G = __v_78 * __v_110; let __v_118: G = __v_80 * __v_111; let __v_119: G = __v_82 * __v_112; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_117 + __v_120; let __v_122: G = __v_116 + __v_121; let __v_123: G = __v_115 + __v_122; let __v_124: G = __v_114 + __v_123; let __v_125: G = __v_113 + __v_124; let __v_126: G = __v_105 + __v_125; if (__v_126 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_127: G = __v_112 - __v_91; let __v_128: G = __v_111 + __v_127; let __v_129: G = __v_110 + __v_128; let __v_130: G = __v_109 + __v_129; let __v_131: G = G::from_bool(__v_130 == G::ZERO); let __v_132: G = __v_107 + __v_108; let __v_133: G = __v_106 + __v_132; let __v_134: G = __v_105 + __v_133; let __v_135: G = G::from_bool(__v_134 == G::ZERO); let __v_136: G = __v_101 - __v_135; let __v_137: G = __v_131 * __v_136; let __v_138: G = __v_101 - __v_137; if (__v_138 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes(); let __v_139: G = G::from_u8(__gb[0]); let __v_140: G = G::from_u8(__gb[1]); let __v_141: G = G::from_u8(__gb[2]); let __v_142: G = G::from_u8(__gb[3]); let __v_143: G = G::from_u8(__gb[4]); let __v_144: G = G::from_u8(__gb[5]); let __v_145: G = G::from_u8(__gb[6]); let __v_146: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_139; let __vj = __v_140; 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_141; let __vj = __v_142; 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_143; let __vj = __v_144; 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_145; let __vj = __v_146; 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_147: G = __v_70 * __v_140; let __v_148: G = __v_72 * __v_141; let __v_149: G = __v_74 * __v_142; let __v_150: G = __v_76 * __v_143; let __v_151: G = __v_78 * __v_144; let __v_152: G = __v_80 * __v_145; let __v_153: G = __v_82 * __v_146; let __v_154: G = __v_152 + __v_153; let __v_155: G = __v_151 + __v_154; let __v_156: G = __v_150 + __v_155; let __v_157: G = __v_149 + __v_156; let __v_158: G = __v_148 + __v_157; let __v_159: G = __v_147 + __v_158; let __v_160: G = __v_139 + __v_159; if (__v_160 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_161: G = __v_146 - __v_91; let __v_162: G = __v_145 + __v_161; let __v_163: G = __v_144 + __v_162; let __v_164: G = __v_143 + __v_163; let __v_165: G = G::from_bool(__v_164 == G::ZERO); let __v_166: G = __v_141 + __v_142; let __v_167: G = __v_140 + __v_166; let __v_168: G = __v_139 + __v_167; let __v_169: G = G::from_bool(__v_168 == G::ZERO); let __v_170: G = __v_101 - __v_169; let __v_171: G = __v_165 * __v_170; let __v_172: G = __v_101 - __v_171; if (__v_172 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __v_173: G = __v_1 - __v_101; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __v_176: G = __r_arr[2]; let __v_177: G = { let __values: [G; 11] = [__v_46, __v_47, __v_44, __v_51, __v_32, __v_55, __v_42, __v_2, __v_12, __v_60, __v_174]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_178: G = { let __values: [G; 10] = [__v_46, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_175]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_179: G = { let __values: [G; 10] = [__v_46, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_178]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_180: G = { let __values: [G; 10] = [__v_46, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_179]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_181: G = { let __values: [G; 10] = [__v_46, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_180]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_182: G = { let __values: [G; 10] = [__v_46, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_181]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_183: G = { let __values: [G; 10] = [__v_46, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_182]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_184: G = { let __values: [G; 10] = [__v_46, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_183]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_177, __v_184, __v_176]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_101: usize = 1; const IN_101: usize = 1; const OUT_101: usize = 3; -fn aiur_fn_101(inp: [G; IN_101], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_101] = [__v_3, __v_3, __v_2]; record.function_queries[101].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_101] = [__v_7, __v_5, __v_6]; record.function_queries[101].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_101(inp: [G; IN_101], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_101] = [__v_3, __v_3, __v_2]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_101] = [__v_7, __v_5, __v_6]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_102: usize = 2; const IN_102: usize = 2; const OUT_102: usize = 2; -fn aiur_fn_102(inp: [G; IN_102], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_3, __v_0]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; 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_102] = { let __args: [G; IN_102] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, (&__args[..]))?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { (*(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102])) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { 65535u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_9, __v_7]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_10, __v_7]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_102(inp: [G; IN_102], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_3, __v_0]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; 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_102] = { let __args: [G; IN_102] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, &__args[..])?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { 65535u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_9, __v_7]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_10, __v_7]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_103: usize = 1; const IN_103: usize = 1; const OUT_103: usize = 9; -fn aiur_fn_103(inp: [G; IN_103], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_103(inp: [G; IN_103], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[103].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_104: usize = 1; const IN_104: usize = 1; const OUT_104: usize = 13; -fn aiur_fn_104(inp: [G; IN_104], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = __r_arr[4]; let __v_86: G = __r_arr[5]; let __v_87: G = __r_arr[6]; let __v_88: G = __r_arr[7]; let __v_89: G = __r_arr[8]; let __v_90: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, (&__args[..]))?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { (*(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101])) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_96, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, (&__args[..]))?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { (*(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102])) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = { let __values: [G; 10] = [__v_71, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_92]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_80, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_100, __v_91, __v_94, __v_95, __v_97, __v_98]; record.function_queries[104].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_104(inp: [G; IN_104], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = __r_arr[4]; let __v_86: G = __r_arr[5]; let __v_87: G = __r_arr[6]; let __v_88: G = __r_arr[7]; let __v_89: G = __r_arr[8]; let __v_90: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, &__args[..])?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_96, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, &__args[..])?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = { let __values: [G; 10] = [__v_71, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_92]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_80, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, &__args[..])?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_100, __v_91, __v_94, __v_95, __v_97, __v_98]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_105: usize = 5; const IN_105: usize = 5; const OUT_105: usize = 1; -fn aiur_fn_105(inp: [G; IN_105], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_9]; record.function_queries[105].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_105(inp: [G; IN_105], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_9]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_106: usize = 33; const IN_106: usize = 33; const OUT_106: usize = 1; -fn aiur_fn_106(inp: [G; IN_106], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_106] = [__v_40]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_106(inp: [G; IN_106], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_106] = [__v_40]; record.function_queries[106].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_107: usize = 32; const IN_107: usize = 32; const OUT_107: usize = 32; -fn aiur_fn_107(inp: [G; IN_107], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __ret: [G; OUT_107] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; record.function_queries[107].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_107(inp: [G; IN_107], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __ret: [G; OUT_107] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; record.function_queries[107].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_108: usize = 2; const IN_108: usize = 2; const OUT_108: usize = 1; -fn aiur_fn_108(inp: [G; IN_108], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); let __v_5: G = G::from_u64(106); let __v_6: G = G::from_u64(133); let __v_7: G = G::from_u64(174); let __v_8: G = G::from_u64(187); let __v_9: G = G::from_u64(114); let __v_10: G = G::from_u64(243); let __v_11: G = G::from_u64(110); let __v_12: G = G::from_u64(60); let __v_13: G = G::from_u64(58); let __v_14: G = G::from_u64(245); let __v_15: G = G::from_u64(79); let __v_16: G = G::from_u64(165); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(82); let __v_19: G = G::from_u64(14); let __v_20: G = G::from_u64(81); let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(104); let __v_23: G = G::from_u64(5); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(171); let __v_26: G = G::from_u64(217); let __v_27: G = G::from_u64(131); let __v_28: G = G::from_u64(31); let __v_29: G = G::from_u64(25); let __v_30: G = G::from_u64(205); let __v_31: G = G::from_u64(224); let __v_32: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; let __v_36: G = __loaded[3]; let __v_37: G = __loaded[4]; let __v_38: G = __loaded[5]; let __v_39: G = __loaded[6]; let __v_40: G = __loaded[7]; let __v_41: G = __loaded[8]; let __v_42: G = __loaded[9]; let __v_43: G = __loaded[10]; let __v_44: G = __loaded[11]; let __v_45: G = __loaded[12]; let __v_46: G = __loaded[13]; let __v_47: G = __loaded[14]; let __v_48: G = __loaded[15]; let __v_49: G = __loaded[16]; let __v_50: G = __loaded[17]; let __v_51: G = __loaded[18]; let __v_52: G = __loaded[19]; let __v_53: G = __loaded[20]; let __v_54: G = __loaded[21]; let __v_55: G = __loaded[22]; let __v_56: G = __loaded[23]; let __v_57: G = __loaded[24]; let __v_58: G = __loaded[25]; let __v_59: G = __loaded[26]; let __v_60: G = __loaded[27]; let __v_61: G = __loaded[28]; let __v_62: G = __loaded[29]; let __v_63: G = __loaded[30]; let __v_64: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_65: G = __loaded[0]; let __v_66: G = __loaded[1]; let __v_67: G = __loaded[2]; let __v_68: G = __loaded[3]; let __v_69: G = __loaded[4]; let __v_70: G = __loaded[5]; let __v_71: G = __loaded[6]; let __v_72: G = __loaded[7]; let __v_73: G = __loaded[8]; let __v_74: G = __loaded[9]; let __v_75: G = __loaded[10]; let __v_76: G = __loaded[11]; let __v_77: G = __loaded[12]; let __v_78: G = __loaded[13]; let __v_79: G = __loaded[14]; let __v_80: G = __loaded[15]; let __v_81: G = __loaded[16]; let __v_82: G = __loaded[17]; let __v_83: G = __loaded[18]; let __v_84: G = __loaded[19]; let __v_85: G = __loaded[20]; let __v_86: G = __loaded[21]; let __v_87: G = __loaded[22]; let __v_88: G = __loaded[23]; let __v_89: G = __loaded[24]; let __v_90: G = __loaded[25]; let __v_91: G = __loaded[26]; let __v_92: G = __loaded[27]; let __v_93: G = __loaded[28]; let __v_94: G = __loaded[29]; let __v_95: G = __loaded[30]; let __v_96: G = __loaded[31]; let __v_97: G = G::from_u64(0); let __v_98: G = G::from_u64(64); let __v_99: G = G::from_u64(11); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_97, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_98, __v_97, __v_97, __v_97, __v_99, __v_97, __v_97, __v_97, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; let __v_103: G = __r_arr[3]; let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = __r_arr[6]; let __v_107: G = __r_arr[7]; let __v_108: G = __r_arr[8]; let __v_109: G = __r_arr[9]; let __v_110: G = __r_arr[10]; let __v_111: G = __r_arr[11]; let __v_112: G = __r_arr[12]; let __v_113: G = __r_arr[13]; let __v_114: G = __r_arr[14]; let __v_115: G = __r_arr[15]; let __v_116: G = __r_arr[16]; let __v_117: G = __r_arr[17]; let __v_118: G = __r_arr[18]; let __v_119: G = __r_arr[19]; let __v_120: G = __r_arr[20]; let __v_121: G = __r_arr[21]; let __v_122: G = __r_arr[22]; let __v_123: G = __r_arr[23]; let __v_124: G = __r_arr[24]; let __v_125: G = __r_arr[25]; let __v_126: G = __r_arr[26]; let __v_127: G = __r_arr[27]; let __v_128: G = __r_arr[28]; let __v_129: G = __r_arr[29]; let __v_130: G = __r_arr[30]; let __v_131: G = __r_arr[31]; let __v_132: G = { let __values: [G; 32] = [__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_130, __v_131]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_108] = [__v_132]; record.function_queries[108].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_108(inp: [G; IN_108], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); let __v_5: G = G::from_u64(106); let __v_6: G = G::from_u64(133); let __v_7: G = G::from_u64(174); let __v_8: G = G::from_u64(187); let __v_9: G = G::from_u64(114); let __v_10: G = G::from_u64(243); let __v_11: G = G::from_u64(110); let __v_12: G = G::from_u64(60); let __v_13: G = G::from_u64(58); let __v_14: G = G::from_u64(245); let __v_15: G = G::from_u64(79); let __v_16: G = G::from_u64(165); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(82); let __v_19: G = G::from_u64(14); let __v_20: G = G::from_u64(81); let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(104); let __v_23: G = G::from_u64(5); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(171); let __v_26: G = G::from_u64(217); let __v_27: G = G::from_u64(131); let __v_28: G = G::from_u64(31); let __v_29: G = G::from_u64(25); let __v_30: G = G::from_u64(205); let __v_31: G = G::from_u64(224); let __v_32: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; let __v_36: G = __loaded[3]; let __v_37: G = __loaded[4]; let __v_38: G = __loaded[5]; let __v_39: G = __loaded[6]; let __v_40: G = __loaded[7]; let __v_41: G = __loaded[8]; let __v_42: G = __loaded[9]; let __v_43: G = __loaded[10]; let __v_44: G = __loaded[11]; let __v_45: G = __loaded[12]; let __v_46: G = __loaded[13]; let __v_47: G = __loaded[14]; let __v_48: G = __loaded[15]; let __v_49: G = __loaded[16]; let __v_50: G = __loaded[17]; let __v_51: G = __loaded[18]; let __v_52: G = __loaded[19]; let __v_53: G = __loaded[20]; let __v_54: G = __loaded[21]; let __v_55: G = __loaded[22]; let __v_56: G = __loaded[23]; let __v_57: G = __loaded[24]; let __v_58: G = __loaded[25]; let __v_59: G = __loaded[26]; let __v_60: G = __loaded[27]; let __v_61: G = __loaded[28]; let __v_62: G = __loaded[29]; let __v_63: G = __loaded[30]; let __v_64: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_65: G = __loaded[0]; let __v_66: G = __loaded[1]; let __v_67: G = __loaded[2]; let __v_68: G = __loaded[3]; let __v_69: G = __loaded[4]; let __v_70: G = __loaded[5]; let __v_71: G = __loaded[6]; let __v_72: G = __loaded[7]; let __v_73: G = __loaded[8]; let __v_74: G = __loaded[9]; let __v_75: G = __loaded[10]; let __v_76: G = __loaded[11]; let __v_77: G = __loaded[12]; let __v_78: G = __loaded[13]; let __v_79: G = __loaded[14]; let __v_80: G = __loaded[15]; let __v_81: G = __loaded[16]; let __v_82: G = __loaded[17]; let __v_83: G = __loaded[18]; let __v_84: G = __loaded[19]; let __v_85: G = __loaded[20]; let __v_86: G = __loaded[21]; let __v_87: G = __loaded[22]; let __v_88: G = __loaded[23]; let __v_89: G = __loaded[24]; let __v_90: G = __loaded[25]; let __v_91: G = __loaded[26]; let __v_92: G = __loaded[27]; let __v_93: G = __loaded[28]; let __v_94: G = __loaded[29]; let __v_95: G = __loaded[30]; let __v_96: G = __loaded[31]; let __v_97: G = G::from_u64(0); let __v_98: G = G::from_u64(64); let __v_99: G = G::from_u64(11); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_97, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_98, __v_97, __v_97, __v_97, __v_99, __v_97, __v_97, __v_97, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; let __v_103: G = __r_arr[3]; let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = __r_arr[6]; let __v_107: G = __r_arr[7]; let __v_108: G = __r_arr[8]; let __v_109: G = __r_arr[9]; let __v_110: G = __r_arr[10]; let __v_111: G = __r_arr[11]; let __v_112: G = __r_arr[12]; let __v_113: G = __r_arr[13]; let __v_114: G = __r_arr[14]; let __v_115: G = __r_arr[15]; let __v_116: G = __r_arr[16]; let __v_117: G = __r_arr[17]; let __v_118: G = __r_arr[18]; let __v_119: G = __r_arr[19]; let __v_120: G = __r_arr[20]; let __v_121: G = __r_arr[21]; let __v_122: G = __r_arr[22]; let __v_123: G = __r_arr[23]; let __v_124: G = __r_arr[24]; let __v_125: G = __r_arr[25]; let __v_126: G = __r_arr[26]; let __v_127: G = __r_arr[27]; let __v_128: G = __r_arr[28]; let __v_129: G = __r_arr[29]; let __v_130: G = __r_arr[30]; let __v_131: G = __r_arr[31]; let __v_132: G = { let __values: [G; 32] = [__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_130, __v_131]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_108] = [__v_132]; record.function_queries[108].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_109: usize = 3; const IN_109: usize = 3; const OUT_109: usize = 1; -fn aiur_fn_109(inp: [G; IN_109], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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 __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_109(inp: [G; IN_109], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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 __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_110: usize = 2; const IN_110: usize = 2; const OUT_110: usize = 1; -fn aiur_fn_110(inp: [G; IN_110], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_110] = [__v_5]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_3 - __v_1); let __v_6: G = G::from_bool((__v_5 == G::ZERO)); match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, (&__args[..]))?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { (*(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110])) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_110(inp: [G; IN_110], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_110] = [__v_5]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_3 - __v_1; let __v_6: G = G::from_bool(__v_5 == G::ZERO); match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, &__args[..])?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_111: usize = 3; const IN_111: usize = 3; const OUT_111: usize = 1; -fn aiur_fn_111(inp: [G; IN_111], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_7]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = (__v_7 - __v_2); let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_11]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_21]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_23]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_111(inp: [G; IN_111], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_7]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = __v_7 - __v_2; let __v_10: G = G::from_bool(__v_9 == G::ZERO); match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_11]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_21]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_23]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_112: usize = 3; const IN_112: usize = 3; const OUT_112: usize = 1; -fn aiur_fn_112(inp: [G; IN_112], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_7]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_10]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_20]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_22]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_112(inp: [G; IN_112], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_7]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_10]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_20]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_22]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_113: usize = 2; const IN_113: usize = 2; const OUT_113: usize = 11; -fn aiur_fn_113(inp: [G; IN_113], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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() { 0u64 => { let __v_12: G = G::from_u64(256); let __v_13: G = (__v_12 * __v_4); let __v_14: G = G::from_u64(65536); let __v_15: G = (__v_14 * __v_5); let __v_16: G = G::from_u64(16777216); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(4294967296); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(1099511627776); let __v_21: G = (__v_20 * __v_8); let __v_22: G = G::from_u64(281474976710656); let __v_23: G = (__v_22 * __v_9); let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = (__v_24 * __v_10); let __v_26: G = (__v_23 + __v_25); let __v_27: G = (__v_21 + __v_26); let __v_28: G = (__v_19 + __v_27); let __v_29: G = (__v_17 + __v_28); let __v_30: G = (__v_15 + __v_29); let __v_31: G = (__v_13 + __v_30); let __v_32: G = (__v_3 + __v_31); let __gb: [u8; 8] = __v_32.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 = (__v_12 * __v_34); let __v_42: G = (__v_14 * __v_35); let __v_43: G = (__v_16 * __v_36); let __v_44: G = (__v_18 * __v_37); let __v_45: G = (__v_20 * __v_38); let __v_46: G = (__v_22 * __v_39); let __v_47: G = (__v_24 * __v_40); let __v_48: G = (__v_46 + __v_47); let __v_49: G = (__v_45 + __v_48); let __v_50: G = (__v_44 + __v_49); let __v_51: G = (__v_43 + __v_50); let __v_52: G = (__v_42 + __v_51); let __v_53: G = (__v_41 + __v_52); let __v_54: G = (__v_33 + __v_53); if (__v_54 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_55: G = G::from_u64(1020); let __v_56: G = (__v_40 - __v_55); let __v_57: G = (__v_39 + __v_56); let __v_58: G = (__v_38 + __v_57); let __v_59: G = (__v_37 + __v_58); let __v_60: G = G::from_bool((__v_59 == G::ZERO)); let __v_61: G = (__v_35 + __v_36); let __v_62: G = (__v_34 + __v_61); let __v_63: G = (__v_33 + __v_62); let __v_64: G = G::from_bool((__v_63 == G::ZERO)); let __v_65: G = G::from_u64(1); let __v_66: G = (__v_65 - __v_64); let __v_67: G = (__v_60 * __v_66); let __v_68: G = (__v_65 - __v_67); if (__v_68 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_113] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_65]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_0, __v_1, __v_15]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; let __v_21: G = __r_arr[6]; let __v_22: G = __r_arr[7]; 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_113] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_113(inp: [G; IN_113], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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() { 0u64 => { let __v_12: G = G::from_u64(256); let __v_13: G = __v_12 * __v_4; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_5; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_6; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_7; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_8; let __v_22: G = G::from_u64(281474976710656); let __v_23: G = __v_22 * __v_9; let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = __v_24 * __v_10; let __v_26: G = __v_23 + __v_25; let __v_27: G = __v_21 + __v_26; let __v_28: G = __v_19 + __v_27; let __v_29: G = __v_17 + __v_28; let __v_30: G = __v_15 + __v_29; let __v_31: G = __v_13 + __v_30; let __v_32: G = __v_3 + __v_31; let __gb: [u8; 8] = __v_32.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 = __v_12 * __v_34; let __v_42: G = __v_14 * __v_35; let __v_43: G = __v_16 * __v_36; let __v_44: G = __v_18 * __v_37; let __v_45: G = __v_20 * __v_38; let __v_46: G = __v_22 * __v_39; let __v_47: G = __v_24 * __v_40; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_45 + __v_48; let __v_50: G = __v_44 + __v_49; let __v_51: G = __v_43 + __v_50; let __v_52: G = __v_42 + __v_51; let __v_53: G = __v_41 + __v_52; let __v_54: G = __v_33 + __v_53; if (__v_54 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_55: G = G::from_u64(1020); let __v_56: G = __v_40 - __v_55; let __v_57: G = __v_39 + __v_56; let __v_58: G = __v_38 + __v_57; let __v_59: G = __v_37 + __v_58; let __v_60: G = G::from_bool(__v_59 == G::ZERO); let __v_61: G = __v_35 + __v_36; let __v_62: G = __v_34 + __v_61; let __v_63: G = __v_33 + __v_62; let __v_64: G = G::from_bool(__v_63 == G::ZERO); let __v_65: G = G::from_u64(1); let __v_66: G = __v_65 - __v_64; let __v_67: G = __v_60 * __v_66; let __v_68: G = __v_65 - __v_67; if (__v_68 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_113] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_65]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_0, __v_1, __v_15]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; let __v_21: G = __r_arr[6]; let __v_22: G = __r_arr[7]; 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_113] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_114: usize = 6; const IN_114: usize = 6; const OUT_114: usize = 1; -fn aiur_fn_114(inp: [G; IN_114], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_113] = { let __args: [G; IN_113] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __v_9: G = __r_arr[3]; let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = __r_arr[6]; let __v_13: G = __r_arr[7]; let __v_14: G = __r_arr[8]; let __v_15: G = __r_arr[9]; let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; let __v_29: G = __loaded[4]; let __v_30: G = __loaded[5]; let __v_31: G = __loaded[6]; let __v_32: G = __loaded[7]; let __v_33: G = __loaded[8]; let __v_34: G = __loaded[9]; let __v_35: G = __loaded[10]; let __v_36: G = __loaded[11]; let __v_37: G = __loaded[12]; let __v_38: G = __loaded[13]; let __v_39: G = __loaded[14]; let __v_40: G = __loaded[15]; let __v_41: G = __loaded[16]; let __v_42: G = __loaded[17]; let __v_43: G = __loaded[18]; let __v_44: G = __loaded[19]; let __v_45: G = __loaded[20]; let __v_46: G = __loaded[21]; let __v_47: G = __loaded[22]; let __v_48: G = __loaded[23]; let __v_49: G = __loaded[24]; let __v_50: G = __loaded[25]; let __v_51: G = __loaded[26]; let __v_52: G = __loaded[27]; let __v_53: G = __loaded[28]; let __v_54: G = __loaded[29]; let __v_55: G = __loaded[30]; let __v_56: G = __loaded[31]; let __v_57: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; let __v_61: G = __loaded[3]; let __v_62: G = __loaded[4]; let __v_63: G = __loaded[5]; let __v_64: G = __loaded[6]; let __v_65: G = __loaded[7]; let __v_66: G = G::from_u64(11); let __v_67: G = G::from_u64(103); let __v_68: G = G::from_u64(230); let __v_69: G = G::from_u64(9); let __v_70: G = G::from_u64(106); let __v_71: G = G::from_u64(133); let __v_72: G = G::from_u64(174); let __v_73: G = G::from_u64(187); let __v_74: G = G::from_u64(114); let __v_75: G = G::from_u64(243); let __v_76: G = G::from_u64(110); let __v_77: G = G::from_u64(60); let __v_78: G = G::from_u64(58); let __v_79: G = G::from_u64(245); let __v_80: G = G::from_u64(79); let __v_81: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_57, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_67, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_57, __v_57, __v_57, __v_57, __v_66, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; let __v_85: G = __r_arr[3]; let __v_86: G = __r_arr[4]; let __v_87: G = __r_arr[5]; let __v_88: G = __r_arr[6]; let __v_89: G = __r_arr[7]; let __v_90: G = __r_arr[8]; let __v_91: G = __r_arr[9]; let __v_92: G = __r_arr[10]; let __v_93: G = __r_arr[11]; let __v_94: G = __r_arr[12]; let __v_95: G = __r_arr[13]; let __v_96: G = __r_arr[14]; let __v_97: G = __r_arr[15]; let __v_98: G = __r_arr[16]; let __v_99: G = __r_arr[17]; let __v_100: G = __r_arr[18]; let __v_101: G = __r_arr[19]; let __v_102: G = __r_arr[20]; let __v_103: G = __r_arr[21]; let __v_104: G = __r_arr[22]; let __v_105: G = __r_arr[23]; let __v_106: G = __r_arr[24]; let __v_107: G = __r_arr[25]; let __v_108: G = __r_arr[26]; let __v_109: G = __r_arr[27]; let __v_110: G = __r_arr[28]; let __v_111: G = __r_arr[29]; let __v_112: G = __r_arr[30]; let __v_113: G = __r_arr[31]; let __v_114: G = { let __values: [G; 34] = [__v_57, __v_5, __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]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_114]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; 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_113] = { let __args: [G; IN_113] = [__v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_69, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; 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_113] = { let __args: [G; IN_113] = [__v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; let __v_86: G = __r_arr[3]; let __v_87: G = __r_arr[4]; let __v_88: G = __r_arr[5]; let __v_89: G = __r_arr[6]; let __v_90: G = __r_arr[7]; let __v_91: G = __r_arr[8]; let __v_92: G = __r_arr[9]; let __v_93: G = __r_arr[10]; let __v_94: G = G::from_u64(8); let __v_95: G = (__v_82 + __v_93); let __v_96: G = (__v_71 + __v_95); let __v_97: G = (__v_60 + __v_96); let __v_98: G = (__v_49 + __v_97); let __v_99: G = (__v_38 + __v_98); let __v_100: G = (__v_27 + __v_99); let __v_101: G = (__v_16 + __v_100); let __v_102: G = (__v_94 * __v_101); let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; let __v_106: G = __loaded[3]; let __v_107: G = __loaded[4]; let __v_108: G = __loaded[5]; let __v_109: G = __loaded[6]; let __v_110: G = __loaded[7]; let __v_111: G = __loaded[8]; let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; match __v_113.as_canonical_u64() { 1u64 => { let __v_116: G = G::from_u64(1); break '__mc_0 [__v_116]; }, _ => { let __v_116: G = G::from_u64(0); break '__mc_0 [__v_116]; }, } }, _ => { let __v_113: G = G::from_u64(0); break '__mc_0 [__v_113]; }, } }; let __v_113: G = __mc_out___mc_0[0]; let __v_114: G = G::from_u64(15); let __v_115: G = (__v_2 - __v_114); let __v_116: G = G::from_bool((__v_115 == G::ZERO)); let __v_117: G = G::from_bool((__v_2 == G::ZERO)); let __v_118: G = (__v_113 * __v_116); let __v_119: G = (__v_116 - __v_118); let __v_120: G = (__v_113 + __v_119); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; let __v_124: G = __loaded[3]; let __v_125: G = __loaded[4]; let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; 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 ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_129: G = __r_arr[0]; let __v_130: G = (__v_113 * __v_129); let __v_131: G = G::from_u64(2); let __v_132: G = (__v_131 * __v_120); let __v_133: G = G::from_u64(8); let __v_134: G = (__v_133 * __v_130); let __v_135: G = (__v_132 + __v_134); let __v_136: G = (__v_117 + __v_135); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; let __v_140: G = __loaded[3]; let __v_141: G = __loaded[4]; let __v_142: G = __loaded[5]; let __v_143: G = __loaded[6]; let __v_144: G = __loaded[7]; let __v_145: G = __loaded[8]; let __v_146: G = __loaded[9]; let __v_147: G = __loaded[10]; let __v_148: G = __loaded[11]; let __v_149: G = __loaded[12]; let __v_150: G = __loaded[13]; let __v_151: G = __loaded[14]; let __v_152: G = __loaded[15]; let __v_153: G = __loaded[16]; let __v_154: G = __loaded[17]; let __v_155: G = __loaded[18]; let __v_156: G = __loaded[19]; let __v_157: G = __loaded[20]; let __v_158: G = __loaded[21]; let __v_159: G = __loaded[22]; let __v_160: G = __loaded[23]; let __v_161: G = __loaded[24]; let __v_162: G = __loaded[25]; let __v_163: G = __loaded[26]; let __v_164: G = __loaded[27]; let __v_165: G = __loaded[28]; let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; let __v_169: G = G::from_u64(103); let __v_170: G = G::from_u64(230); let __v_171: G = G::from_u64(9); let __v_172: G = G::from_u64(106); let __v_173: G = G::from_u64(133); let __v_174: G = G::from_u64(174); let __v_175: G = G::from_u64(187); let __v_176: G = G::from_u64(114); let __v_177: G = G::from_u64(243); let __v_178: G = G::from_u64(110); let __v_179: G = G::from_u64(60); let __v_180: G = G::from_u64(58); let __v_181: G = G::from_u64(245); let __v_182: G = G::from_u64(79); let __v_183: G = G::from_u64(165); let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_184, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_169, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_102, __v_184, __v_184, __v_184, __v_136, __v_184, __v_184, __v_184, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_195: G = __r_arr[10]; let __v_196: G = __r_arr[11]; let __v_197: G = __r_arr[12]; let __v_198: G = __r_arr[13]; let __v_199: G = __r_arr[14]; let __v_200: G = __r_arr[15]; let __v_201: G = __r_arr[16]; let __v_202: G = __r_arr[17]; let __v_203: G = __r_arr[18]; let __v_204: G = __r_arr[19]; let __v_205: G = __r_arr[20]; let __v_206: G = __r_arr[21]; let __v_207: G = __r_arr[22]; let __v_208: G = __r_arr[23]; let __v_209: G = __r_arr[24]; let __v_210: G = __r_arr[25]; let __v_211: G = __r_arr[26]; let __v_212: G = __r_arr[27]; let __v_213: G = __r_arr[28]; let __v_214: G = __r_arr[29]; let __v_215: G = __r_arr[30]; let __v_216: G = __r_arr[31]; match __v_113.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(0); let __v_218: G = { let __values: [G; 34] = [__v_217, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_218]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_116.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(103); let __v_218: G = G::from_u64(230); let __v_219: G = G::from_u64(9); let __v_220: G = G::from_u64(106); let __v_221: G = G::from_u64(133); let __v_222: G = G::from_u64(174); let __v_223: G = G::from_u64(187); let __v_224: G = G::from_u64(114); let __v_225: G = G::from_u64(243); let __v_226: G = G::from_u64(110); let __v_227: G = G::from_u64(60); let __v_228: G = G::from_u64(58); let __v_229: G = G::from_u64(245); let __v_230: G = G::from_u64(79); let __v_231: G = G::from_u64(165); let __v_232: G = G::from_u64(127); let __v_233: G = G::from_u64(82); let __v_234: G = G::from_u64(14); let __v_235: G = G::from_u64(81); let __v_236: G = G::from_u64(140); let __v_237: G = G::from_u64(104); let __v_238: G = G::from_u64(5); let __v_239: G = G::from_u64(155); let __v_240: G = G::from_u64(171); let __v_241: G = G::from_u64(217); let __v_242: G = G::from_u64(131); let __v_243: G = G::from_u64(31); let __v_244: G = G::from_u64(25); let __v_245: G = G::from_u64(205); let __v_246: G = G::from_u64(224); let __v_247: G = G::from_u64(91); let __v_248: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_249: G = __loaded[0]; let __v_250: G = __loaded[1]; let __v_251: G = __loaded[2]; let __v_252: G = __loaded[3]; let __v_253: G = __loaded[4]; let __v_254: G = __loaded[5]; let __v_255: G = __loaded[6]; let __v_256: G = __loaded[7]; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, (&__args[..]))?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { (*(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11])) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_257: G = __r_arr[0]; let __v_258: G = __r_arr[1]; let __v_259: G = __r_arr[2]; let __v_260: G = __r_arr[3]; let __v_261: G = __r_arr[4]; let __v_262: G = __r_arr[5]; let __v_263: G = __r_arr[6]; let __v_264: G = __r_arr[7]; let __v_265: G = { let __values: [G; 8] = [__v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_266: G = { let __values: [G; 32] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_217, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_267: G = { let __values: [G; 34] = [__v_248, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_268: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_268]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_217: G = G::from_u64(1); let __v_218: G = (__v_2 + __v_217); let __v_219: G = { let __values: [G; 32] = [__v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_220]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +fn aiur_fn_114(inp: [G; IN_114], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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_113] = { let __args: [G; IN_113] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __v_9: G = __r_arr[3]; let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = __r_arr[6]; let __v_13: G = __r_arr[7]; let __v_14: G = __r_arr[8]; let __v_15: G = __r_arr[9]; let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; let __v_29: G = __loaded[4]; let __v_30: G = __loaded[5]; let __v_31: G = __loaded[6]; let __v_32: G = __loaded[7]; let __v_33: G = __loaded[8]; let __v_34: G = __loaded[9]; let __v_35: G = __loaded[10]; let __v_36: G = __loaded[11]; let __v_37: G = __loaded[12]; let __v_38: G = __loaded[13]; let __v_39: G = __loaded[14]; let __v_40: G = __loaded[15]; let __v_41: G = __loaded[16]; let __v_42: G = __loaded[17]; let __v_43: G = __loaded[18]; let __v_44: G = __loaded[19]; let __v_45: G = __loaded[20]; let __v_46: G = __loaded[21]; let __v_47: G = __loaded[22]; let __v_48: G = __loaded[23]; let __v_49: G = __loaded[24]; let __v_50: G = __loaded[25]; let __v_51: G = __loaded[26]; let __v_52: G = __loaded[27]; let __v_53: G = __loaded[28]; let __v_54: G = __loaded[29]; let __v_55: G = __loaded[30]; let __v_56: G = __loaded[31]; let __v_57: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; let __v_61: G = __loaded[3]; let __v_62: G = __loaded[4]; let __v_63: G = __loaded[5]; let __v_64: G = __loaded[6]; let __v_65: G = __loaded[7]; let __v_66: G = G::from_u64(11); let __v_67: G = G::from_u64(103); let __v_68: G = G::from_u64(230); let __v_69: G = G::from_u64(9); let __v_70: G = G::from_u64(106); let __v_71: G = G::from_u64(133); let __v_72: G = G::from_u64(174); let __v_73: G = G::from_u64(187); let __v_74: G = G::from_u64(114); let __v_75: G = G::from_u64(243); let __v_76: G = G::from_u64(110); let __v_77: G = G::from_u64(60); let __v_78: G = G::from_u64(58); let __v_79: G = G::from_u64(245); let __v_80: G = G::from_u64(79); let __v_81: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_57, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_67, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_57, __v_57, __v_57, __v_57, __v_66, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; let __v_85: G = __r_arr[3]; let __v_86: G = __r_arr[4]; let __v_87: G = __r_arr[5]; let __v_88: G = __r_arr[6]; let __v_89: G = __r_arr[7]; let __v_90: G = __r_arr[8]; let __v_91: G = __r_arr[9]; let __v_92: G = __r_arr[10]; let __v_93: G = __r_arr[11]; let __v_94: G = __r_arr[12]; let __v_95: G = __r_arr[13]; let __v_96: G = __r_arr[14]; let __v_97: G = __r_arr[15]; let __v_98: G = __r_arr[16]; let __v_99: G = __r_arr[17]; let __v_100: G = __r_arr[18]; let __v_101: G = __r_arr[19]; let __v_102: G = __r_arr[20]; let __v_103: G = __r_arr[21]; let __v_104: G = __r_arr[22]; let __v_105: G = __r_arr[23]; let __v_106: G = __r_arr[24]; let __v_107: G = __r_arr[25]; let __v_108: G = __r_arr[26]; let __v_109: G = __r_arr[27]; let __v_110: G = __r_arr[28]; let __v_111: G = __r_arr[29]; let __v_112: G = __r_arr[30]; let __v_113: G = __r_arr[31]; let __v_114: G = { let __values: [G; 34] = [__v_57, __v_5, __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]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_114]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; 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_113] = { let __args: [G; IN_113] = [__v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_69, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; 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_113] = { let __args: [G; IN_113] = [__v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; let __v_86: G = __r_arr[3]; let __v_87: G = __r_arr[4]; let __v_88: G = __r_arr[5]; let __v_89: G = __r_arr[6]; let __v_90: G = __r_arr[7]; let __v_91: G = __r_arr[8]; let __v_92: G = __r_arr[9]; let __v_93: G = __r_arr[10]; let __v_94: G = G::from_u64(8); let __v_95: G = __v_82 + __v_93; let __v_96: G = __v_71 + __v_95; let __v_97: G = __v_60 + __v_96; let __v_98: G = __v_49 + __v_97; let __v_99: G = __v_38 + __v_98; let __v_100: G = __v_27 + __v_99; let __v_101: G = __v_16 + __v_100; let __v_102: G = __v_94 * __v_101; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; let __v_106: G = __loaded[3]; let __v_107: G = __loaded[4]; let __v_108: G = __loaded[5]; let __v_109: G = __loaded[6]; let __v_110: G = __loaded[7]; let __v_111: G = __loaded[8]; let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; match __v_113.as_canonical_u64() { 1u64 => { let __v_116: G = G::from_u64(1); break '__mc_0 [__v_116]; }, _ => { let __v_116: G = G::from_u64(0); break '__mc_0 [__v_116]; }, } }, _ => { let __v_113: G = G::from_u64(0); break '__mc_0 [__v_113]; }, } }; let __v_113: G = __mc_out___mc_0[0]; let __v_114: G = G::from_u64(15); let __v_115: G = __v_2 - __v_114; let __v_116: G = G::from_bool(__v_115 == G::ZERO); let __v_117: G = G::from_bool(__v_2 == G::ZERO); let __v_118: G = __v_113 * __v_116; let __v_119: G = __v_116 - __v_118; let __v_120: G = __v_113 + __v_119; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; let __v_124: G = __loaded[3]; let __v_125: G = __loaded[4]; let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; 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 ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_129: G = __r_arr[0]; let __v_130: G = __v_113 * __v_129; let __v_131: G = G::from_u64(2); let __v_132: G = __v_131 * __v_120; let __v_133: G = G::from_u64(8); let __v_134: G = __v_133 * __v_130; let __v_135: G = __v_132 + __v_134; let __v_136: G = __v_117 + __v_135; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; let __v_140: G = __loaded[3]; let __v_141: G = __loaded[4]; let __v_142: G = __loaded[5]; let __v_143: G = __loaded[6]; let __v_144: G = __loaded[7]; let __v_145: G = __loaded[8]; let __v_146: G = __loaded[9]; let __v_147: G = __loaded[10]; let __v_148: G = __loaded[11]; let __v_149: G = __loaded[12]; let __v_150: G = __loaded[13]; let __v_151: G = __loaded[14]; let __v_152: G = __loaded[15]; let __v_153: G = __loaded[16]; let __v_154: G = __loaded[17]; let __v_155: G = __loaded[18]; let __v_156: G = __loaded[19]; let __v_157: G = __loaded[20]; let __v_158: G = __loaded[21]; let __v_159: G = __loaded[22]; let __v_160: G = __loaded[23]; let __v_161: G = __loaded[24]; let __v_162: G = __loaded[25]; let __v_163: G = __loaded[26]; let __v_164: G = __loaded[27]; let __v_165: G = __loaded[28]; let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; let __v_169: G = G::from_u64(103); let __v_170: G = G::from_u64(230); let __v_171: G = G::from_u64(9); let __v_172: G = G::from_u64(106); let __v_173: G = G::from_u64(133); let __v_174: G = G::from_u64(174); let __v_175: G = G::from_u64(187); let __v_176: G = G::from_u64(114); let __v_177: G = G::from_u64(243); let __v_178: G = G::from_u64(110); let __v_179: G = G::from_u64(60); let __v_180: G = G::from_u64(58); let __v_181: G = G::from_u64(245); let __v_182: G = G::from_u64(79); let __v_183: G = G::from_u64(165); let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_184, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_169, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_102, __v_184, __v_184, __v_184, __v_136, __v_184, __v_184, __v_184, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_195: G = __r_arr[10]; let __v_196: G = __r_arr[11]; let __v_197: G = __r_arr[12]; let __v_198: G = __r_arr[13]; let __v_199: G = __r_arr[14]; let __v_200: G = __r_arr[15]; let __v_201: G = __r_arr[16]; let __v_202: G = __r_arr[17]; let __v_203: G = __r_arr[18]; let __v_204: G = __r_arr[19]; let __v_205: G = __r_arr[20]; let __v_206: G = __r_arr[21]; let __v_207: G = __r_arr[22]; let __v_208: G = __r_arr[23]; let __v_209: G = __r_arr[24]; let __v_210: G = __r_arr[25]; let __v_211: G = __r_arr[26]; let __v_212: G = __r_arr[27]; let __v_213: G = __r_arr[28]; let __v_214: G = __r_arr[29]; let __v_215: G = __r_arr[30]; let __v_216: G = __r_arr[31]; match __v_113.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(0); let __v_218: G = { let __values: [G; 34] = [__v_217, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_218]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_116.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(103); let __v_218: G = G::from_u64(230); let __v_219: G = G::from_u64(9); let __v_220: G = G::from_u64(106); let __v_221: G = G::from_u64(133); let __v_222: G = G::from_u64(174); let __v_223: G = G::from_u64(187); let __v_224: G = G::from_u64(114); let __v_225: G = G::from_u64(243); let __v_226: G = G::from_u64(110); let __v_227: G = G::from_u64(60); let __v_228: G = G::from_u64(58); let __v_229: G = G::from_u64(245); let __v_230: G = G::from_u64(79); let __v_231: G = G::from_u64(165); let __v_232: G = G::from_u64(127); let __v_233: G = G::from_u64(82); let __v_234: G = G::from_u64(14); let __v_235: G = G::from_u64(81); let __v_236: G = G::from_u64(140); let __v_237: G = G::from_u64(104); let __v_238: G = G::from_u64(5); let __v_239: G = G::from_u64(155); let __v_240: G = G::from_u64(171); let __v_241: G = G::from_u64(217); let __v_242: G = G::from_u64(131); let __v_243: G = G::from_u64(31); let __v_244: G = G::from_u64(25); let __v_245: G = G::from_u64(205); let __v_246: G = G::from_u64(224); let __v_247: G = G::from_u64(91); let __v_248: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_249: G = __loaded[0]; let __v_250: G = __loaded[1]; let __v_251: G = __loaded[2]; let __v_252: G = __loaded[3]; let __v_253: G = __loaded[4]; let __v_254: G = __loaded[5]; let __v_255: G = __loaded[6]; let __v_256: G = __loaded[7]; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, &__args[..])?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { *(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11]) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_257: G = __r_arr[0]; let __v_258: G = __r_arr[1]; let __v_259: G = __r_arr[2]; let __v_260: G = __r_arr[3]; let __v_261: G = __r_arr[4]; let __v_262: G = __r_arr[5]; let __v_263: G = __r_arr[6]; let __v_264: G = __r_arr[7]; let __v_265: G = { let __values: [G; 8] = [__v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_266: G = { let __values: [G; 32] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_217, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_267: G = { let __values: [G; 34] = [__v_248, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_268: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_268]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_217: G = G::from_u64(1); let __v_218: G = __v_2 + __v_217; let __v_219: G = { let __values: [G; 32] = [__v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_220]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_115: usize = 1; const IN_115: usize = 1; const OUT_115: usize = 32; -fn aiur_fn_115(inp: [G; IN_115], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 10] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__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_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]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_115] = [__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]; record.function_queries[115].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_115(inp: [G; IN_115], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 10] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__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_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]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_115] = [__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]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_116: usize = 3; const IN_116: usize = 3; const OUT_116: usize = 1; -fn aiur_fn_116(inp: [G; IN_116], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(103); let __v_5: G = G::from_u64(230); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(133); let __v_9: G = G::from_u64(174); let __v_10: G = G::from_u64(187); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(243); let __v_13: G = G::from_u64(110); let __v_14: G = G::from_u64(60); let __v_15: G = G::from_u64(58); let __v_16: G = G::from_u64(245); let __v_17: G = G::from_u64(79); let __v_18: G = G::from_u64(165); let __v_19: G = G::from_u64(127); let __v_20: G = G::from_u64(82); let __v_21: G = G::from_u64(14); let __v_22: G = G::from_u64(81); let __v_23: G = G::from_u64(140); let __v_24: G = G::from_u64(104); let __v_25: G = G::from_u64(5); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(171); let __v_28: G = G::from_u64(217); let __v_29: G = G::from_u64(131); let __v_30: G = G::from_u64(31); let __v_31: G = G::from_u64(25); let __v_32: G = G::from_u64(205); let __v_33: G = G::from_u64(224); let __v_34: G = G::from_u64(91); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 10] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 8] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_4, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 34] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; let __v_45: G = __r_arr[3]; let __v_46: G = __r_arr[4]; let __v_47: G = __r_arr[5]; let __v_48: G = __r_arr[6]; let __v_49: G = __r_arr[7]; let __v_50: G = __r_arr[8]; let __v_51: G = __r_arr[9]; let __v_52: G = __r_arr[10]; let __v_53: G = __r_arr[11]; let __v_54: G = __r_arr[12]; let __v_55: G = __r_arr[13]; let __v_56: G = __r_arr[14]; let __v_57: G = __r_arr[15]; let __v_58: G = __r_arr[16]; let __v_59: G = __r_arr[17]; let __v_60: G = __r_arr[18]; let __v_61: G = __r_arr[19]; let __v_62: G = __r_arr[20]; let __v_63: G = __r_arr[21]; let __v_64: G = __r_arr[22]; let __v_65: G = __r_arr[23]; let __v_66: G = __r_arr[24]; let __v_67: G = __r_arr[25]; let __v_68: G = __r_arr[26]; let __v_69: G = __r_arr[27]; let __v_70: G = __r_arr[28]; let __v_71: G = __r_arr[29]; let __v_72: G = __r_arr[30]; let __v_73: G = __r_arr[31]; let __v_74: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_116] = [__v_74]; record.function_queries[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_116(inp: [G; IN_116], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(103); let __v_5: G = G::from_u64(230); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(133); let __v_9: G = G::from_u64(174); let __v_10: G = G::from_u64(187); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(243); let __v_13: G = G::from_u64(110); let __v_14: G = G::from_u64(60); let __v_15: G = G::from_u64(58); let __v_16: G = G::from_u64(245); let __v_17: G = G::from_u64(79); let __v_18: G = G::from_u64(165); let __v_19: G = G::from_u64(127); let __v_20: G = G::from_u64(82); let __v_21: G = G::from_u64(14); let __v_22: G = G::from_u64(81); let __v_23: G = G::from_u64(140); let __v_24: G = G::from_u64(104); let __v_25: G = G::from_u64(5); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(171); let __v_28: G = G::from_u64(217); let __v_29: G = G::from_u64(131); let __v_30: G = G::from_u64(31); let __v_31: G = G::from_u64(25); let __v_32: G = G::from_u64(205); let __v_33: G = G::from_u64(224); let __v_34: G = G::from_u64(91); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 10] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 8] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_4, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 34] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; let __v_45: G = __r_arr[3]; let __v_46: G = __r_arr[4]; let __v_47: G = __r_arr[5]; let __v_48: G = __r_arr[6]; let __v_49: G = __r_arr[7]; let __v_50: G = __r_arr[8]; let __v_51: G = __r_arr[9]; let __v_52: G = __r_arr[10]; let __v_53: G = __r_arr[11]; let __v_54: G = __r_arr[12]; let __v_55: G = __r_arr[13]; let __v_56: G = __r_arr[14]; let __v_57: G = __r_arr[15]; let __v_58: G = __r_arr[16]; let __v_59: G = __r_arr[17]; let __v_60: G = __r_arr[18]; let __v_61: G = __r_arr[19]; let __v_62: G = __r_arr[20]; let __v_63: G = __r_arr[21]; let __v_64: G = __r_arr[22]; let __v_65: G = __r_arr[23]; let __v_66: G = __r_arr[24]; let __v_67: G = __r_arr[25]; let __v_68: G = __r_arr[26]; let __v_69: G = __r_arr[27]; let __v_70: G = __r_arr[28]; let __v_71: G = __r_arr[29]; let __v_72: G = __r_arr[30]; let __v_73: G = __r_arr[31]; let __v_74: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_116] = [__v_74]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_117: usize = 4; const IN_117: usize = 4; const OUT_117: usize = 1; -fn aiur_fn_117(inp: [G; IN_117], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __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_110] = { let __args: [G; IN_110] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, (&__args[..]))?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { (*(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110])) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_117] = [__v_3]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_6]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_117(inp: [G; IN_117], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __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_110] = { let __args: [G; IN_110] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, &__args[..])?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_117] = [__v_3]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_6]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_118: usize = 1; const IN_118: usize = 1; const OUT_118: usize = 1; -fn aiur_fn_118(inp: [G; IN_118], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_118] = [__v_4]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; 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_118] = [__v_7]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_118(inp: [G; IN_118], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_118] = [__v_4]; record.function_queries[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; 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_118] = [__v_7]; record.function_queries[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_119: usize = 2; const IN_119: usize = 2; const OUT_119: usize = 1; -fn aiur_fn_119(inp: [G; IN_119], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_1]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_119] = [__v_0]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; 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 ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; 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_119] = { let __args: [G; IN_119] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_17]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; 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_119] = { let __args: [G; IN_119] = [__v_7, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_119(inp: [G; IN_119], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_1]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_119] = [__v_0]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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 ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; 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_119] = { let __args: [G; IN_119] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_17]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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_119] = { let __args: [G; IN_119] = [__v_7, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_120: usize = 1; const IN_120: usize = 1; const OUT_120: usize = 2; -fn aiur_fn_120(inp: [G; IN_120], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 6] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_8, __v_8]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 6] = [__v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_15]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_15]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_17]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_120(inp: [G; IN_120], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 6] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_8, __v_8]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 6] = [__v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_15]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_15]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, &__args[..])?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_17]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_121: usize = 1; const IN_121: usize = 1; const OUT_121: usize = 1; -fn aiur_fn_121(inp: [G; IN_121], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_121] = [__v_0]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_121] = [__v_0]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_17]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_121(inp: [G; IN_121], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_121] = [__v_0]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_121] = [__v_0]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, &__args[..])?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_17]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_122: usize = 4; const IN_122: usize = 4; const OUT_122: usize = 1; -fn aiur_fn_122(inp: [G; IN_122], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; 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 = { let __values: [G; 6] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_10]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_14]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_122(inp: [G; IN_122], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; 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 = { let __values: [G; 6] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_10]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_14]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_123: usize = 4; const IN_123: usize = 4; const OUT_123: usize = 2; -fn aiur_fn_123(inp: [G; IN_123], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 6] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_11, __v_1]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; 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_112] = { let __args: [G; IN_112] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; 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_108] = { let __args: [G; IN_108] = [__v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; 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_29, __v_30]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_33, __v_31]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, (&__args[..]))?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { (*(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109])) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_34, __v_32]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; 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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, (&__args[..]))?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { (*(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109])) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; 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 = { let __values: [G; 6] = [__v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_27]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_28, __v_22]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; 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())); }, } }) } +fn aiur_fn_123(inp: [G; IN_123], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 6] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_11, __v_1]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; 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_112] = { let __args: [G; IN_112] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; 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_108] = { let __args: [G; IN_108] = [__v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; 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_29, __v_30]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_33, __v_31]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, &__args[..])?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_34, __v_32]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, &__args[..])?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; 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 = { let __values: [G; 6] = [__v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_27]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_28, __v_22]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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_124: usize = 4; const IN_124: usize = 4; const OUT_124: usize = 2; -fn aiur_fn_124(inp: [G; IN_124], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_124] = [__v_0, __v_1]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_3 - __v_4); let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_6, __v_7, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, (&__args[..]))?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { (*(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124])) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_124] = [__v_8, __v_9]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_124(inp: [G; IN_124], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_124] = [__v_0, __v_1]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_3 - __v_4; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_6, __v_7, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, &__args[..])?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_124] = [__v_8, __v_9]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_125: usize = 6; const IN_125: usize = 6; const OUT_125: usize = 1; -fn aiur_fn_125(inp: [G; IN_125], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_12, __v_4, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, (&__args[..]))?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { (*(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124])) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; 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 }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_21); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); let __ret: [G; OUT_125] = [__v_27]; record.function_queries[125].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } +fn aiur_fn_125(inp: [G; IN_125], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __v_6 - __v_7; let __v_9: G = G::from_bool(__v_8 == G::ZERO); let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_12, __v_4, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, &__args[..])?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; 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 }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __v_25 - __v_21; let __v_27: G = G::from_bool(__v_26 == G::ZERO); let __ret: [G; OUT_125] = [__v_27]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } const INPUT_SIZE_126: usize = 2; const IN_126: usize = 2; const OUT_126: usize = 1; -fn aiur_fn_126(inp: [G; IN_126], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_126] = [__v_1]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_7]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_126(inp: [G; IN_126], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_126] = [__v_1]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_7]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_127: usize = 2; const IN_127: usize = 2; const OUT_127: usize = 1; -fn aiur_fn_127(inp: [G; IN_127], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_127] = [__v_5]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_0 * __v_0); let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_6]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = (__v_0 * __v_6); let __ret: [G; OUT_127] = [__v_7]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_127(inp: [G; IN_127], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_127] = [__v_5]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_0 * __v_0; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_6]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = __v_0 * __v_6; let __ret: [G; OUT_127] = [__v_7]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_128: usize = 8; const IN_128: usize = 8; const OUT_128: usize = 2; -fn aiur_fn_128(inp: [G; IN_128], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_13); let __v_15: G = (__v_4 + __v_6); let __v_16: G = (__v_5 + __v_7); let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); let __v_19: G = (__v_17 * __v_17); let __v_20: G = G::from_u64(7); let __v_21: G = (__v_18 * __v_18); let __v_22: G = (__v_20 * __v_21); let __v_23: G = (__v_19 - __v_22); let __v_24: G = aiur::execute::g_inverse_value(__v_23); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_25 - __v_8); let __v_27: G = (__v_23 * __v_26); if (__v_27 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_28: G = (__v_24 * __v_26); if (__v_28 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_29: G = (__v_17 * __v_24); let __v_30: G = (__v_18 - __v_18); let __v_31: G = (__v_30 * __v_24); let __v_32: G = (__v_15 * __v_29); let __v_33: G = (__v_16 * __v_31); let __v_34: G = (__v_20 * __v_33); let __v_35: G = (__v_32 + __v_34); let __v_36: G = (__v_15 * __v_31); let __v_37: G = (__v_16 * __v_29); let __v_38: G = (__v_36 + __v_37); let __v_39: G = (__v_4 - __v_6); let __v_40: G = (__v_5 - __v_7); let __v_41: G = (__v_14 * __v_14); let __v_42: G = (__v_41 - __v_22); let __v_43: G = aiur::execute::g_inverse_value(__v_42); let __v_44: G = (__v_42 * __v_43); let __v_45: G = (__v_44 - __v_8); let __v_46: G = (__v_42 * __v_45); if (__v_46 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_47: G = (__v_43 * __v_45); if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_48: G = (__v_14 * __v_43); let __v_49: G = (__v_30 * __v_43); let __v_50: G = (__v_39 * __v_48); let __v_51: G = (__v_40 * __v_49); let __v_52: G = (__v_20 * __v_51); let __v_53: G = (__v_50 + __v_52); let __v_54: G = (__v_39 * __v_49); let __v_55: G = (__v_40 * __v_48); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_2 * __v_53); let __v_58: G = (__v_3 * __v_56); let __v_59: G = (__v_20 * __v_58); let __v_60: G = (__v_57 + __v_59); let __v_61: G = (__v_2 * __v_56); let __v_62: G = (__v_3 * __v_53); let __v_63: G = (__v_61 + __v_62); let __v_64: G = (__v_35 + __v_60); let __v_65: G = (__v_38 + __v_63); let __ret: [G; OUT_128] = [__v_64, __v_65]; record.function_queries[128].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_128(inp: [G; IN_128], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 + __v_8; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_13; let __v_15: G = __v_4 + __v_6; let __v_16: G = __v_5 + __v_7; let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); let __v_19: G = __v_17 * __v_17; let __v_20: G = G::from_u64(7); let __v_21: G = __v_18 * __v_18; let __v_22: G = __v_20 * __v_21; let __v_23: G = __v_19 - __v_22; let __v_24: G = aiur::execute::g_inverse_value(__v_23); let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_25 - __v_8; let __v_27: G = __v_23 * __v_26; if (__v_27 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_28: G = __v_24 * __v_26; if (__v_28 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_29: G = __v_17 * __v_24; let __v_30: G = __v_18 - __v_18; let __v_31: G = __v_30 * __v_24; let __v_32: G = __v_15 * __v_29; let __v_33: G = __v_16 * __v_31; let __v_34: G = __v_20 * __v_33; let __v_35: G = __v_32 + __v_34; let __v_36: G = __v_15 * __v_31; let __v_37: G = __v_16 * __v_29; let __v_38: G = __v_36 + __v_37; let __v_39: G = __v_4 - __v_6; let __v_40: G = __v_5 - __v_7; let __v_41: G = __v_14 * __v_14; let __v_42: G = __v_41 - __v_22; let __v_43: G = aiur::execute::g_inverse_value(__v_42); let __v_44: G = __v_42 * __v_43; let __v_45: G = __v_44 - __v_8; let __v_46: G = __v_42 * __v_45; if (__v_46 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_47: G = __v_43 * __v_45; if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_48: G = __v_14 * __v_43; let __v_49: G = __v_30 * __v_43; let __v_50: G = __v_39 * __v_48; let __v_51: G = __v_40 * __v_49; let __v_52: G = __v_20 * __v_51; let __v_53: G = __v_50 + __v_52; let __v_54: G = __v_39 * __v_49; let __v_55: G = __v_40 * __v_48; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_2 * __v_53; let __v_58: G = __v_3 * __v_56; let __v_59: G = __v_20 * __v_58; let __v_60: G = __v_57 + __v_59; let __v_61: G = __v_2 * __v_56; let __v_62: G = __v_3 * __v_53; let __v_63: G = __v_61 + __v_62; let __v_64: G = __v_35 + __v_60; let __v_65: G = __v_38 + __v_63; let __ret: [G; OUT_128] = [__v_64, __v_65]; record.function_queries[128].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_129: usize = 2; const IN_129: usize = 2; const OUT_129: usize = 1; -fn aiur_fn_129(inp: [G; IN_129], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_2 * __v_7); let __ret: [G; OUT_129] = [__v_8]; record.function_queries[129].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_129(inp: [G; IN_129], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __v_2 * __v_7; let __ret: [G; OUT_129] = [__v_8]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_130: usize = 8; const IN_130: usize = 8; const OUT_130: usize = 4; -fn aiur_fn_130(inp: [G; IN_130], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_130] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; match __v_18.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(256); let __v_23: G = (__v_22 * __v_10); let __v_24: G = G::from_u64(65536); let __v_25: G = (__v_24 * __v_11); let __v_26: G = G::from_u64(16777216); let __v_27: G = (__v_26 * __v_12); let __v_28: G = G::from_u64(4294967296); let __v_29: G = (__v_28 * __v_13); let __v_30: G = G::from_u64(1099511627776); let __v_31: G = (__v_30 * __v_14); let __v_32: G = G::from_u64(281474976710656); let __v_33: G = (__v_32 * __v_15); let __v_34: G = G::from_u64(72057594037927936); let __v_35: G = (__v_34 * __v_16); let __v_36: G = (__v_33 + __v_35); let __v_37: G = (__v_31 + __v_36); let __v_38: G = (__v_29 + __v_37); let __v_39: G = (__v_27 + __v_38); let __v_40: G = (__v_25 + __v_39); let __v_41: G = (__v_23 + __v_40); let __v_42: G = (__v_9 + __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = (__v_19 - __v_42); let __v_45: G = (__v_20 - __v_43); let __v_46: G = (__v_6 * __v_44); let __v_47: G = G::from_u64(7); let __v_48: G = (__v_7 * __v_45); let __v_49: G = (__v_47 * __v_48); let __v_50: G = (__v_46 + __v_49); let __v_51: G = (__v_6 * __v_45); let __v_52: G = (__v_7 * __v_44); let __v_53: G = (__v_51 + __v_52); let __v_54: G = (__v_4 + __v_50); let __v_55: G = (__v_5 + __v_53); let __v_56: G = (__v_6 * __v_2); let __v_57: G = (__v_7 * __v_3); let __v_58: G = (__v_47 * __v_57); let __v_59: G = (__v_56 + __v_58); let __v_60: G = (__v_6 * __v_3); let __v_61: G = (__v_7 * __v_2); let __v_62: G = (__v_60 + __v_61); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __ret: [G; OUT_130] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +fn aiur_fn_130(inp: [G; IN_130], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_130] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; match __v_18.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(256); let __v_23: G = __v_22 * __v_10; let __v_24: G = G::from_u64(65536); let __v_25: G = __v_24 * __v_11; let __v_26: G = G::from_u64(16777216); let __v_27: G = __v_26 * __v_12; let __v_28: G = G::from_u64(4294967296); let __v_29: G = __v_28 * __v_13; let __v_30: G = G::from_u64(1099511627776); let __v_31: G = __v_30 * __v_14; let __v_32: G = G::from_u64(281474976710656); let __v_33: G = __v_32 * __v_15; let __v_34: G = G::from_u64(72057594037927936); let __v_35: G = __v_34 * __v_16; let __v_36: G = __v_33 + __v_35; let __v_37: G = __v_31 + __v_36; let __v_38: G = __v_29 + __v_37; let __v_39: G = __v_27 + __v_38; let __v_40: G = __v_25 + __v_39; let __v_41: G = __v_23 + __v_40; let __v_42: G = __v_9 + __v_41; let __v_43: G = G::from_u64(0); let __v_44: G = __v_19 - __v_42; let __v_45: G = __v_20 - __v_43; let __v_46: G = __v_6 * __v_44; let __v_47: G = G::from_u64(7); let __v_48: G = __v_7 * __v_45; let __v_49: G = __v_47 * __v_48; let __v_50: G = __v_46 + __v_49; let __v_51: G = __v_6 * __v_45; let __v_52: G = __v_7 * __v_44; let __v_53: G = __v_51 + __v_52; let __v_54: G = __v_4 + __v_50; let __v_55: G = __v_5 + __v_53; let __v_56: G = __v_6 * __v_2; let __v_57: G = __v_7 * __v_3; let __v_58: G = __v_47 * __v_57; let __v_59: G = __v_56 + __v_58; let __v_60: G = __v_6 * __v_3; let __v_61: G = __v_7 * __v_2; let __v_62: G = __v_60 + __v_61; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, &__args[..])?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __ret: [G; OUT_130] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_131: usize = 2; const IN_131: usize = 2; const OUT_131: usize = 1; -fn aiur_fn_131(inp: [G; IN_131], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_131] = [__v_1]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_6: G = G::from_u8(__gb[0]); let __v_7: G = G::from_u8(__gb[1]); let __v_8: G = G::from_u8(__gb[2]); let __v_9: G = G::from_u8(__gb[3]); let __v_10: G = G::from_u8(__gb[4]); let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; 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_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)); } let __v_14: G = G::from_u64(256); let __v_15: G = (__v_14 * __v_7); let __v_16: G = G::from_u64(65536); let __v_17: G = (__v_16 * __v_8); let __v_18: G = G::from_u64(16777216); let __v_19: G = (__v_18 * __v_9); let __v_20: G = G::from_u64(4294967296); let __v_21: G = (__v_20 * __v_10); let __v_22: G = G::from_u64(1099511627776); let __v_23: G = (__v_22 * __v_11); let __v_24: G = G::from_u64(281474976710656); let __v_25: G = (__v_24 * __v_12); let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = (__v_26 * __v_13); let __v_28: G = (__v_25 + __v_27); let __v_29: G = (__v_23 + __v_28); let __v_30: G = (__v_21 + __v_29); let __v_31: G = (__v_19 + __v_30); let __v_32: G = (__v_17 + __v_31); let __v_33: G = (__v_15 + __v_32); let __v_34: G = (__v_6 + __v_33); if (__v_34 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_35: G = G::from_u64(1020); let __v_36: G = (__v_13 - __v_35); let __v_37: G = (__v_12 + __v_36); let __v_38: G = (__v_11 + __v_37); let __v_39: G = (__v_10 + __v_38); let __v_40: G = G::from_bool((__v_39 == G::ZERO)); let __v_41: G = (__v_8 + __v_9); let __v_42: G = (__v_7 + __v_41); let __v_43: G = (__v_6 + __v_42); let __v_44: G = G::from_bool((__v_43 == G::ZERO)); let __v_45: G = G::from_u64(1); let __v_46: G = (__v_45 - __v_44); let __v_47: G = (__v_40 * __v_46); let __v_48: G = (__v_45 - __v_47); if (__v_48 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes(); let __v_49: G = G::from_u8(__gb[0]); let __v_50: G = G::from_u8(__gb[1]); let __v_51: G = G::from_u8(__gb[2]); let __v_52: G = G::from_u8(__gb[3]); let __v_53: G = G::from_u8(__gb[4]); let __v_54: G = G::from_u8(__gb[5]); let __v_55: G = G::from_u8(__gb[6]); let __v_56: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; 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_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)); } let __v_57: G = (__v_14 * __v_50); let __v_58: G = (__v_16 * __v_51); let __v_59: G = (__v_18 * __v_52); let __v_60: G = (__v_20 * __v_53); let __v_61: G = (__v_22 * __v_54); let __v_62: G = (__v_24 * __v_55); let __v_63: G = (__v_26 * __v_56); let __v_64: G = (__v_62 + __v_63); let __v_65: G = (__v_61 + __v_64); let __v_66: G = (__v_60 + __v_65); let __v_67: G = (__v_59 + __v_66); let __v_68: G = (__v_58 + __v_67); let __v_69: G = (__v_57 + __v_68); let __v_70: G = (__v_49 + __v_69); if (__v_70 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } let __v_71: G = (__v_56 - __v_35); let __v_72: G = (__v_55 + __v_71); let __v_73: G = (__v_54 + __v_72); let __v_74: G = (__v_53 + __v_73); let __v_75: G = G::from_bool((__v_74 == G::ZERO)); let __v_76: G = (__v_51 + __v_52); let __v_77: G = (__v_50 + __v_76); let __v_78: G = (__v_49 + __v_77); let __v_79: G = G::from_bool((__v_78 == G::ZERO)); let __v_80: G = (__v_45 - __v_79); let __v_81: G = (__v_75 * __v_80); let __v_82: G = (__v_45 - __v_81); if (__v_82 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_85]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_131(inp: [G; IN_131], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_131] = [__v_1]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_6: G = G::from_u8(__gb[0]); let __v_7: G = G::from_u8(__gb[1]); let __v_8: G = G::from_u8(__gb[2]); let __v_9: G = G::from_u8(__gb[3]); let __v_10: G = G::from_u8(__gb[4]); let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); 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); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; 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_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); } let __v_14: G = G::from_u64(256); let __v_15: G = __v_14 * __v_7; let __v_16: G = G::from_u64(65536); let __v_17: G = __v_16 * __v_8; let __v_18: G = G::from_u64(16777216); let __v_19: G = __v_18 * __v_9; let __v_20: G = G::from_u64(4294967296); let __v_21: G = __v_20 * __v_10; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_11; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_12; let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = __v_26 * __v_13; let __v_28: G = __v_25 + __v_27; let __v_29: G = __v_23 + __v_28; let __v_30: G = __v_21 + __v_29; let __v_31: G = __v_19 + __v_30; let __v_32: G = __v_17 + __v_31; let __v_33: G = __v_15 + __v_32; let __v_34: G = __v_6 + __v_33; if (__v_34 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_35: G = G::from_u64(1020); let __v_36: G = __v_13 - __v_35; let __v_37: G = __v_12 + __v_36; let __v_38: G = __v_11 + __v_37; let __v_39: G = __v_10 + __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = __v_8 + __v_9; let __v_42: G = __v_7 + __v_41; let __v_43: G = __v_6 + __v_42; let __v_44: G = G::from_bool(__v_43 == G::ZERO); let __v_45: G = G::from_u64(1); let __v_46: G = __v_45 - __v_44; let __v_47: G = __v_40 * __v_46; let __v_48: G = __v_45 - __v_47; if (__v_48 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes(); let __v_49: G = G::from_u8(__gb[0]); let __v_50: G = G::from_u8(__gb[1]); let __v_51: G = G::from_u8(__gb[2]); let __v_52: G = G::from_u8(__gb[3]); let __v_53: G = G::from_u8(__gb[4]); let __v_54: G = G::from_u8(__gb[5]); let __v_55: G = G::from_u8(__gb[6]); let __v_56: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; 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_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); } let __v_57: G = __v_14 * __v_50; let __v_58: G = __v_16 * __v_51; let __v_59: G = __v_18 * __v_52; let __v_60: G = __v_20 * __v_53; let __v_61: G = __v_22 * __v_54; let __v_62: G = __v_24 * __v_55; let __v_63: G = __v_26 * __v_56; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_61 + __v_64; let __v_66: G = __v_60 + __v_65; let __v_67: G = __v_59 + __v_66; let __v_68: G = __v_58 + __v_67; let __v_69: G = __v_57 + __v_68; let __v_70: G = __v_49 + __v_69; if (__v_70 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } let __v_71: G = __v_56 - __v_35; let __v_72: G = __v_55 + __v_71; let __v_73: G = __v_54 + __v_72; let __v_74: G = __v_53 + __v_73; let __v_75: G = G::from_bool(__v_74 == G::ZERO); let __v_76: G = __v_51 + __v_52; let __v_77: G = __v_50 + __v_76; let __v_78: G = __v_49 + __v_77; let __v_79: G = G::from_bool(__v_78 == G::ZERO); let __v_80: G = __v_45 - __v_79; let __v_81: G = __v_75 * __v_80; let __v_82: G = __v_45 - __v_81; if (__v_82 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_85]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_132: usize = 2; const IN_132: usize = 2; const OUT_132: usize = 1; -fn aiur_fn_132(inp: [G; IN_132], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_132] = [__v_1]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, (&__args[..]))?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { (*(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132])) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_6]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_132(inp: [G; IN_132], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_132] = [__v_1]; record.function_queries[132].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, &__args[..])?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_6]; record.function_queries[132].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_133: usize = 2; const IN_133: usize = 2; const OUT_133: usize = 1; -fn aiur_fn_133(inp: [G; IN_133], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_133] = [__v_1]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, (&__args[..]))?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { (*(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132])) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_6]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_133(inp: [G; IN_133], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_133] = [__v_1]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, &__args[..])?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_6]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_134: usize = 3; const IN_134: usize = 3; const OUT_134: usize = 1; -fn aiur_fn_134(inp: [G; IN_134], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_134] = [__v_2]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_3]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_134(inp: [G; IN_134], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_134] = [__v_2]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_3]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_135: usize = 2; const IN_135: usize = 2; const OUT_135: usize = 1; -fn aiur_fn_135(inp: [G; IN_135], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_135] = [__v_0]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_8]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_135(inp: [G; IN_135], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_135] = [__v_0]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_8]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_136: usize = 10; const IN_136: usize = 10; const OUT_136: usize = 2; -fn aiur_fn_136(inp: [G; IN_136], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_136] = [__v_0, __v_11]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; 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_136] = [__v_14, __v_15]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_136(inp: [G; IN_136], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_136] = [__v_0, __v_11]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; 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_136] = [__v_14, __v_15]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_137: usize = 4; const IN_137: usize = 4; const OUT_137: usize = 2; -fn aiur_fn_137(inp: [G; IN_137], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_8, __v_0]; record.function_queries[137].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; let __v_32: G = __r_arr[12]; let __v_33: G = __r_arr[13]; let __v_34: G = __r_arr[14]; let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, (&__args[..]))?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { (*(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137])) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(256); let __v_41: G = (__v_40 * __v_21); let __v_42: G = G::from_u64(65536); let __v_43: G = (__v_42 * __v_22); let __v_44: G = G::from_u64(16777216); let __v_45: G = (__v_44 * __v_23); let __v_46: G = G::from_u64(4294967296); let __v_47: G = (__v_46 * __v_24); let __v_48: G = G::from_u64(1099511627776); let __v_49: G = (__v_48 * __v_25); let __v_50: G = G::from_u64(281474976710656); let __v_51: G = (__v_50 * __v_26); let __v_52: G = G::from_u64(72057594037927936); let __v_53: G = (__v_52 * __v_27); let __v_54: G = (__v_51 + __v_53); let __v_55: G = (__v_49 + __v_54); let __v_56: G = (__v_47 + __v_55); let __v_57: G = (__v_45 + __v_56); let __v_58: G = (__v_43 + __v_57); let __v_59: G = (__v_41 + __v_58); let __v_60: G = (__v_20 + __v_59); let __v_61: G = G::from_u64(0); let __v_62: G = (__v_40 * __v_29); let __v_63: G = (__v_42 * __v_30); let __v_64: G = (__v_44 * __v_31); let __v_65: G = (__v_46 * __v_32); let __v_66: G = (__v_48 * __v_33); let __v_67: G = (__v_50 * __v_34); let __v_68: G = (__v_52 * __v_35); let __v_69: G = (__v_67 + __v_68); let __v_70: G = (__v_66 + __v_69); let __v_71: G = (__v_65 + __v_70); let __v_72: G = (__v_64 + __v_71); let __v_73: G = (__v_63 + __v_72); let __v_74: G = (__v_62 + __v_73); let __v_75: G = (__v_28 + __v_74); let __v_76: G = { let __values: [G; 4] = [__v_61, __v_60, __v_75, __v_38]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_76, __v_39]; record.function_queries[137].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_137(inp: [G; IN_137], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_8, __v_0]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; let __v_32: G = __r_arr[12]; let __v_33: G = __r_arr[13]; let __v_34: G = __r_arr[14]; let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, &__args[..])?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(256); let __v_41: G = __v_40 * __v_21; let __v_42: G = G::from_u64(65536); let __v_43: G = __v_42 * __v_22; let __v_44: G = G::from_u64(16777216); let __v_45: G = __v_44 * __v_23; let __v_46: G = G::from_u64(4294967296); let __v_47: G = __v_46 * __v_24; let __v_48: G = G::from_u64(1099511627776); let __v_49: G = __v_48 * __v_25; let __v_50: G = G::from_u64(281474976710656); let __v_51: G = __v_50 * __v_26; let __v_52: G = G::from_u64(72057594037927936); let __v_53: G = __v_52 * __v_27; let __v_54: G = __v_51 + __v_53; let __v_55: G = __v_49 + __v_54; let __v_56: G = __v_47 + __v_55; let __v_57: G = __v_45 + __v_56; let __v_58: G = __v_43 + __v_57; let __v_59: G = __v_41 + __v_58; let __v_60: G = __v_20 + __v_59; let __v_61: G = G::from_u64(0); let __v_62: G = __v_40 * __v_29; let __v_63: G = __v_42 * __v_30; let __v_64: G = __v_44 * __v_31; let __v_65: G = __v_46 * __v_32; let __v_66: G = __v_48 * __v_33; let __v_67: G = __v_50 * __v_34; let __v_68: G = __v_52 * __v_35; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_66 + __v_69; let __v_71: G = __v_65 + __v_70; let __v_72: G = __v_64 + __v_71; let __v_73: G = __v_63 + __v_72; let __v_74: G = __v_62 + __v_73; let __v_75: G = __v_28 + __v_74; let __v_76: G = { let __values: [G; 4] = [__v_61, __v_60, __v_75, __v_38]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_76, __v_39]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_138: usize = 5; const IN_138: usize = 5; const OUT_138: usize = 1; -fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_138] = [__v_5]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); let __v_8: G = G::from_bool((__v_7 == G::ZERO)); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_138] = [__v_9]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 - __v_9); let __v_11: G = (__v_3 + __v_9); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_10, __v_11, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, (&__args[..]))?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { (*(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138])) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_12]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_138] = [__v_5]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_1 - __v_4; let __v_7: G = __v_5 + __v_6; let __v_8: G = G::from_bool(__v_7 == G::ZERO); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_138] = [__v_9]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 - __v_9; let __v_11: G = __v_3 + __v_9; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_10, __v_11, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, &__args[..])?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_12]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_139: usize = 4; const IN_139: usize = 4; const OUT_139: usize = 1; -fn aiur_fn_139(inp: [G; IN_139], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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 = { let __values: [G; 7] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_5]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, (&__args[..]))?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { (*(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138])) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; 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_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_8]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_6, __v_6, __v_6, __v_9]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_10]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_139(inp: [G; IN_139], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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 = { let __values: [G; 7] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_5]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, &__args[..])?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; 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_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_8]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = __v_3 - __v_7; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_6, __v_6, __v_6, __v_9]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_10]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_140: usize = 8; const IN_140: usize = 8; const OUT_140: usize = 1; -fn aiur_fn_140(inp: [G; IN_140], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; match __v_8.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 7] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_16]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { _ => { let __v_15: G = (__v_9 - __v_1); let __v_16: G = G::from_bool((__v_15 == G::ZERO)); match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = (__v_4 * __v_18); let __v_23: G = G::from_u64(7); let __v_24: G = (__v_5 * __v_19); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_22 + __v_25); let __v_27: G = (__v_4 * __v_19); let __v_28: G = (__v_5 * __v_18); let __v_29: G = (__v_27 + __v_28); let __v_30: G = (__v_12 + __v_26); let __v_31: G = (__v_13 + __v_29); let __v_32: G = { let __values: [G; 7] = [__v_17, __v_9, __v_20, __v_21, __v_30, __v_31, __v_14]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_32]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, (&__args[..]))?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { (*(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140])) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_19]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +fn aiur_fn_140(inp: [G; IN_140], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; match __v_8.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 7] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_16]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { _ => { let __v_15: G = __v_9 - __v_1; let __v_16: G = G::from_bool(__v_15 == G::ZERO); match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, &__args[..])?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = __v_4 * __v_18; let __v_23: G = G::from_u64(7); let __v_24: G = __v_5 * __v_19; let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_22 + __v_25; let __v_27: G = __v_4 * __v_19; let __v_28: G = __v_5 * __v_18; let __v_29: G = __v_27 + __v_28; let __v_30: G = __v_12 + __v_26; let __v_31: G = __v_13 + __v_29; let __v_32: G = { let __values: [G; 7] = [__v_17, __v_9, __v_20, __v_21, __v_30, __v_31, __v_14]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_32]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, &__args[..])?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_19]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_141: usize = 2; const IN_141: usize = 2; const OUT_141: usize = 1; -fn aiur_fn_141(inp: [G; IN_141], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].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]; match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_141] = [__v_9]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_9: G = (__v_3 - __v_1); let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = (__v_6 - __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = (__v_7 - __v_11); let __v_15: G = G::from_bool((__v_14 == G::ZERO)); let __v_16: G = (__v_13 * __v_15); let __v_17: G = G::from_u64(1); 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_141] = [__v_17]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_11]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_141(inp: [G; IN_141], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].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]; match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_141] = [__v_9]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_9: G = __v_3 - __v_1; let __v_10: G = G::from_bool(__v_9 == G::ZERO); match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = __v_6 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_7 - __v_11; let __v_15: G = G::from_bool(__v_14 == G::ZERO); let __v_16: G = __v_13 * __v_15; let __v_17: G = G::from_u64(1); 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_141] = [__v_17]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, &__args[..])?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_11]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { 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; -fn aiur_fn_142(inp: [G; IN_142], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_142] = [__v_2]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_142] = [__v_2]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_142(inp: [G; IN_142], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_142] = [__v_2]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_142] = [__v_2]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_143: usize = 10; const IN_143: usize = 10; const OUT_143: usize = 1; -fn aiur_fn_143(inp: [G; IN_143], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_10 - __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); 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: None }); } let __v_15: G = (__v_3 - __v_1); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(7); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_17 * __v_21); let __v_23: G = G::from_u64(0); let __v_24: G = (__v_4 - __v_22); let __v_25: G = (__v_5 - __v_23); let __v_26: G = (__v_24 * __v_24); let __v_27: G = (__v_25 * __v_25); let __v_28: G = (__v_17 * __v_27); let __v_29: G = (__v_26 - __v_28); let __v_30: G = aiur::execute::g_inverse_value(__v_29); let __v_31: G = (__v_29 * __v_30); let __v_32: G = (__v_31 - __v_14); let __v_33: G = (__v_29 * __v_32); if (__v_33 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_34: G = (__v_30 * __v_32); if (__v_34 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_35: G = (__v_24 * __v_30); let __v_36: G = (__v_23 - __v_25); let __v_37: G = (__v_36 * __v_30); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_6, __v_7, __v_35, __v_37, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, (&__args[..]))?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { (*(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140])) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_143] = [__v_38]; record.function_queries[143].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_143(inp: [G; IN_143], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __v_10 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); 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: None }); } let __v_15: G = __v_3 - __v_1; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(7); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __v_17 * __v_21; let __v_23: G = G::from_u64(0); let __v_24: G = __v_4 - __v_22; let __v_25: G = __v_5 - __v_23; let __v_26: G = __v_24 * __v_24; let __v_27: G = __v_25 * __v_25; let __v_28: G = __v_17 * __v_27; let __v_29: G = __v_26 - __v_28; let __v_30: G = aiur::execute::g_inverse_value(__v_29); let __v_31: G = __v_29 * __v_30; let __v_32: G = __v_31 - __v_14; let __v_33: G = __v_29 * __v_32; if (__v_33 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_34: G = __v_30 * __v_32; if (__v_34 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_35: G = __v_24 * __v_30; let __v_36: G = __v_23 - __v_25; let __v_37: G = __v_36 * __v_30; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_6, __v_7, __v_35, __v_37, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, &__args[..])?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_143] = [__v_38]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_144: usize = 11; const IN_144: usize = 11; const OUT_144: usize = 1; -fn aiur_fn_144(inp: [G; IN_144], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_5 * __v_15); let __v_17: G = G::from_u64(7); let __v_18: G = (__v_6 * __v_11); let __v_19: G = (__v_17 * __v_18); let __v_20: G = (__v_16 + __v_19); let __v_21: G = (__v_5 * __v_11); let __v_22: G = (__v_6 * __v_15); let __v_23: G = (__v_21 + __v_22); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_24, __v_3, __v_1, __v_2, __v_20, __v_23, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_25]; record.function_queries[144].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_144(inp: [G; IN_144], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __v_5 * __v_15; let __v_17: G = G::from_u64(7); let __v_18: G = __v_6 * __v_11; let __v_19: G = __v_17 * __v_18; let __v_20: G = __v_16 + __v_19; let __v_21: G = __v_5 * __v_11; let __v_22: G = __v_6 * __v_15; let __v_23: G = __v_21 + __v_22; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_24, __v_3, __v_1, __v_2, __v_20, __v_23, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_25]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_145: usize = 13; const IN_145: usize = 13; const OUT_145: usize = 1; -fn aiur_fn_145(inp: [G; IN_145], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_145] = [__v_0]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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 ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; 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 = (__v_5 - __v_18); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_21]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_145(inp: [G; IN_145], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_145] = [__v_0]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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 ((!unconstrained) && record.defer_call(144, &__args[..])?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; 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 = __v_5 - __v_18; let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_21]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_146: usize = 13; const IN_146: usize = 13; const OUT_146: usize = 1; -fn aiur_fn_146(inp: [G; IN_146], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_146] = [__v_0]; record.function_queries[146].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; 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 = (__v_5 - __v_20); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, (&__args[..]))?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { (*(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146])) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_23]; record.function_queries[146].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_146(inp: [G; IN_146], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_146] = [__v_0]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; 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 = __v_5 - __v_20; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, &__args[..])?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_23]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_147: usize = 15; const IN_147: usize = 15; const OUT_147: usize = 1; -fn aiur_fn_147(inp: [G; IN_147], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_147] = [__v_0]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); let __v_19: G = (__v_5 - __v_17); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_19, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_20]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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 ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); let __v_24: G = (__v_5 - __v_22); let __v_25: G = (__v_6 + __v_22); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_24, __v_25, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_26]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_147(inp: [G; IN_147], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_147] = [__v_0]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = __v_4 + __v_17; let __v_19: G = __v_5 - __v_17; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_19, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_20]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_17 + __v_3; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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 ((!unconstrained) && record.defer_call(144, &__args[..])?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = __v_4 + __v_22; let __v_24: G = __v_5 - __v_22; let __v_25: G = __v_6 + __v_22; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_24, __v_25, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_26]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_148: usize = 15; const IN_148: usize = 15; const OUT_148: usize = 1; -fn aiur_fn_148(inp: [G; IN_148], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_148] = [__v_0]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = G::from_bool((__v_19 == G::ZERO)); let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_6, __v_10, __v_5, __v_7, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_8, __v_9, __v_10, __v_22, __v_7, __v_22, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_25]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_148(inp: [G; IN_148], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_148] = [__v_0]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __v_17 - __v_18; let __v_20: G = G::from_bool(__v_19 == G::ZERO); let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_6, __v_10, __v_5, __v_7, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_8, __v_9, __v_10, __v_22, __v_7, __v_22, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_25]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_149: usize = 4; const IN_149: usize = 4; const OUT_149: usize = 1; -fn aiur_fn_149(inp: [G; IN_149], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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 = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_5]; record.function_queries[149].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; 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 = (__v_3 + __v_7); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_11]; record.function_queries[149].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_149(inp: [G; IN_149], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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 = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_5]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; 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 = __v_3 + __v_7; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_11]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_150: usize = 1; const IN_150: usize = 1; const OUT_150: usize = 1; -fn aiur_fn_150(inp: [G; IN_150], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; 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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_150] = [__v_2]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_150(inp: [G; IN_150], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; 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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_150] = [__v_2]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_151: usize = 5; const IN_151: usize = 5; const OUT_151: usize = 1; -fn aiur_fn_151(inp: [G; IN_151], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_6]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); let __v_9: G = (__v_4 + __v_7); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_10]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; 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 = (__v_4 + __v_10); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_7, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_14]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_151(inp: [G; IN_151], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_6]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_3 - __v_7; let __v_9: G = __v_4 + __v_7; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_10]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; 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 = __v_4 + __v_10; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_7, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_14]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_152: usize = 5; const IN_152: usize = 5; const OUT_152: usize = 4; -fn aiur_fn_152(inp: [G; IN_152], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_152] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_152] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_152(inp: [G; IN_152], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_152] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_152] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_153: usize = 4; const IN_153: usize = 4; const OUT_153: usize = 1; -fn aiur_fn_153(inp: [G; IN_153], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); let __v_6: G = G::from_u8(__gb[2]); let __v_7: G = G::from_u8(__gb[3]); let __v_8: G = G::from_u8(__gb[4]); let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; 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_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)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; 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_12: G = G::from_u64(256); let __v_13: G = (__v_12 * __v_5); let __v_14: G = G::from_u64(65536); let __v_15: G = (__v_14 * __v_6); let __v_16: G = G::from_u64(16777216); let __v_17: G = (__v_16 * __v_7); let __v_18: G = G::from_u64(4294967296); let __v_19: G = (__v_18 * __v_8); let __v_20: G = G::from_u64(1099511627776); let __v_21: G = (__v_20 * __v_9); let __v_22: G = G::from_u64(281474976710656); let __v_23: G = (__v_22 * __v_10); let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = (__v_24 * __v_11); let __v_26: G = (__v_23 + __v_25); let __v_27: G = (__v_21 + __v_26); let __v_28: G = (__v_19 + __v_27); let __v_29: G = (__v_17 + __v_28); let __v_30: G = (__v_15 + __v_29); let __v_31: G = (__v_13 + __v_30); let __v_32: G = (__v_4 + __v_31); if (__v_32 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_33: G = G::from_u64(1020); let __v_34: G = (__v_11 - __v_33); let __v_35: G = (__v_10 + __v_34); let __v_36: G = (__v_9 + __v_35); let __v_37: G = (__v_8 + __v_36); let __v_38: G = G::from_bool((__v_37 == G::ZERO)); let __v_39: G = (__v_6 + __v_7); let __v_40: G = (__v_5 + __v_39); let __v_41: G = (__v_4 + __v_40); let __v_42: G = G::from_bool((__v_41 == G::ZERO)); let __v_43: G = G::from_u64(1); let __v_44: G = (__v_43 - __v_42); let __v_45: G = (__v_38 * __v_44); let __v_46: G = (__v_43 - __v_45); if (__v_46 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_47: G = G::from_u8(__gb[0]); let __v_48: G = G::from_u8(__gb[1]); let __v_49: G = G::from_u8(__gb[2]); let __v_50: G = G::from_u8(__gb[3]); let __v_51: G = G::from_u8(__gb[4]); let __v_52: G = G::from_u8(__gb[5]); let __v_53: G = G::from_u8(__gb[6]); let __v_54: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_47; let __vj = __v_48; 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_49; let __vj = __v_50; 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_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)); } let __v_55: G = (__v_12 * __v_48); let __v_56: G = (__v_14 * __v_49); let __v_57: G = (__v_16 * __v_50); let __v_58: G = (__v_18 * __v_51); let __v_59: G = (__v_20 * __v_52); let __v_60: G = (__v_22 * __v_53); let __v_61: G = (__v_24 * __v_54); let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 + __v_62); let __v_64: G = (__v_58 + __v_63); let __v_65: G = (__v_57 + __v_64); let __v_66: G = (__v_56 + __v_65); let __v_67: G = (__v_55 + __v_66); let __v_68: G = (__v_47 + __v_67); if (__v_68 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_69: G = (__v_54 - __v_33); let __v_70: G = (__v_53 + __v_69); let __v_71: G = (__v_52 + __v_70); let __v_72: G = (__v_51 + __v_71); let __v_73: G = G::from_bool((__v_72 == G::ZERO)); let __v_74: G = (__v_49 + __v_50); let __v_75: G = (__v_48 + __v_74); let __v_76: G = (__v_47 + __v_75); let __v_77: G = G::from_bool((__v_76 == G::ZERO)); let __v_78: G = (__v_43 - __v_77); let __v_79: G = (__v_73 * __v_78); let __v_80: G = (__v_43 - __v_79); if (__v_80 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_81: G = G::from_u8(__gb[0]); let __v_82: G = G::from_u8(__gb[1]); let __v_83: G = G::from_u8(__gb[2]); let __v_84: G = G::from_u8(__gb[3]); let __v_85: G = G::from_u8(__gb[4]); let __v_86: G = G::from_u8(__gb[5]); let __v_87: G = G::from_u8(__gb[6]); let __v_88: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_81; let __vj = __v_82; 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_83; let __vj = __v_84; 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_85; let __vj = __v_86; 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_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)); } let __v_89: G = (__v_12 * __v_82); let __v_90: G = (__v_14 * __v_83); let __v_91: G = (__v_16 * __v_84); let __v_92: G = (__v_18 * __v_85); let __v_93: G = (__v_20 * __v_86); let __v_94: G = (__v_22 * __v_87); let __v_95: G = (__v_24 * __v_88); 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 = (__v_90 + __v_99); let __v_101: G = (__v_89 + __v_100); let __v_102: G = (__v_81 + __v_101); if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_103: G = (__v_88 - __v_33); let __v_104: G = (__v_87 + __v_103); let __v_105: G = (__v_86 + __v_104); let __v_106: G = (__v_85 + __v_105); let __v_107: G = G::from_bool((__v_106 == G::ZERO)); let __v_108: G = (__v_83 + __v_84); let __v_109: G = (__v_82 + __v_108); let __v_110: G = (__v_81 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); let __v_112: G = (__v_43 - __v_111); let __v_113: G = (__v_107 * __v_112); let __v_114: G = (__v_43 - __v_113); if (__v_114 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_115: G = G::from_u8(__gb[0]); let __v_116: G = G::from_u8(__gb[1]); let __v_117: G = G::from_u8(__gb[2]); let __v_118: G = G::from_u8(__gb[3]); let __v_119: G = G::from_u8(__gb[4]); let __v_120: G = G::from_u8(__gb[5]); let __v_121: G = G::from_u8(__gb[6]); let __v_122: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_115; let __vj = __v_116; 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_117; let __vj = __v_118; 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_119; let __vj = __v_120; 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_121; let __vj = __v_122; 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_123: G = (__v_12 * __v_116); let __v_124: G = (__v_14 * __v_117); let __v_125: G = (__v_16 * __v_118); let __v_126: G = (__v_18 * __v_119); let __v_127: G = (__v_20 * __v_120); let __v_128: G = (__v_22 * __v_121); let __v_129: G = (__v_24 * __v_122); let __v_130: G = (__v_128 + __v_129); let __v_131: G = (__v_127 + __v_130); let __v_132: G = (__v_126 + __v_131); let __v_133: G = (__v_125 + __v_132); let __v_134: G = (__v_124 + __v_133); let __v_135: G = (__v_123 + __v_134); let __v_136: G = (__v_115 + __v_135); if (__v_136 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_137: G = (__v_122 - __v_33); let __v_138: G = (__v_121 + __v_137); let __v_139: G = (__v_120 + __v_138); let __v_140: G = (__v_119 + __v_139); let __v_141: G = G::from_bool((__v_140 == G::ZERO)); let __v_142: G = (__v_117 + __v_118); let __v_143: G = (__v_116 + __v_142); let __v_144: G = (__v_115 + __v_143); let __v_145: G = G::from_bool((__v_144 == G::ZERO)); let __v_146: G = (__v_43 - __v_145); let __v_147: G = (__v_141 * __v_146); let __v_148: G = (__v_43 - __v_147); if (__v_148 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __v_149: G = G::from_u64(0); let __v_150: G = { let __values: [G; 10] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_151: G = { let __values: [G; 10] = [__v_149, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_150]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_152: G = { let __values: [G; 10] = [__v_149, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_151]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_153: G = { let __values: [G; 10] = [__v_149, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_152]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_154: G = { let __values: [G; 10] = [__v_149, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_153]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_153] = [__v_154]; record.function_queries[153].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_153(inp: [G; IN_153], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); let __v_6: G = G::from_u8(__gb[2]); let __v_7: G = G::from_u8(__gb[3]); let __v_8: G = G::from_u8(__gb[4]); let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; 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_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); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; 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_12: G = G::from_u64(256); let __v_13: G = __v_12 * __v_5; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_6; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_7; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_8; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_9; let __v_22: G = G::from_u64(281474976710656); let __v_23: G = __v_22 * __v_10; let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = __v_24 * __v_11; let __v_26: G = __v_23 + __v_25; let __v_27: G = __v_21 + __v_26; let __v_28: G = __v_19 + __v_27; let __v_29: G = __v_17 + __v_28; let __v_30: G = __v_15 + __v_29; let __v_31: G = __v_13 + __v_30; let __v_32: G = __v_4 + __v_31; if (__v_32 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_33: G = G::from_u64(1020); let __v_34: G = __v_11 - __v_33; let __v_35: G = __v_10 + __v_34; let __v_36: G = __v_9 + __v_35; let __v_37: G = __v_8 + __v_36; let __v_38: G = G::from_bool(__v_37 == G::ZERO); let __v_39: G = __v_6 + __v_7; let __v_40: G = __v_5 + __v_39; let __v_41: G = __v_4 + __v_40; let __v_42: G = G::from_bool(__v_41 == G::ZERO); let __v_43: G = G::from_u64(1); let __v_44: G = __v_43 - __v_42; let __v_45: G = __v_38 * __v_44; let __v_46: G = __v_43 - __v_45; if (__v_46 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_47: G = G::from_u8(__gb[0]); let __v_48: G = G::from_u8(__gb[1]); let __v_49: G = G::from_u8(__gb[2]); let __v_50: G = G::from_u8(__gb[3]); let __v_51: G = G::from_u8(__gb[4]); let __v_52: G = G::from_u8(__gb[5]); let __v_53: G = G::from_u8(__gb[6]); let __v_54: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_47; let __vj = __v_48; 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_49; let __vj = __v_50; 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_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); } let __v_55: G = __v_12 * __v_48; let __v_56: G = __v_14 * __v_49; let __v_57: G = __v_16 * __v_50; let __v_58: G = __v_18 * __v_51; let __v_59: G = __v_20 * __v_52; let __v_60: G = __v_22 * __v_53; let __v_61: G = __v_24 * __v_54; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_59 + __v_62; let __v_64: G = __v_58 + __v_63; let __v_65: G = __v_57 + __v_64; let __v_66: G = __v_56 + __v_65; let __v_67: G = __v_55 + __v_66; let __v_68: G = __v_47 + __v_67; if (__v_68 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_69: G = __v_54 - __v_33; let __v_70: G = __v_53 + __v_69; let __v_71: G = __v_52 + __v_70; let __v_72: G = __v_51 + __v_71; let __v_73: G = G::from_bool(__v_72 == G::ZERO); let __v_74: G = __v_49 + __v_50; let __v_75: G = __v_48 + __v_74; let __v_76: G = __v_47 + __v_75; let __v_77: G = G::from_bool(__v_76 == G::ZERO); let __v_78: G = __v_43 - __v_77; let __v_79: G = __v_73 * __v_78; let __v_80: G = __v_43 - __v_79; if (__v_80 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_81: G = G::from_u8(__gb[0]); let __v_82: G = G::from_u8(__gb[1]); let __v_83: G = G::from_u8(__gb[2]); let __v_84: G = G::from_u8(__gb[3]); let __v_85: G = G::from_u8(__gb[4]); let __v_86: G = G::from_u8(__gb[5]); let __v_87: G = G::from_u8(__gb[6]); let __v_88: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_81; let __vj = __v_82; 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_83; let __vj = __v_84; 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_85; let __vj = __v_86; 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_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); } let __v_89: G = __v_12 * __v_82; let __v_90: G = __v_14 * __v_83; let __v_91: G = __v_16 * __v_84; let __v_92: G = __v_18 * __v_85; let __v_93: G = __v_20 * __v_86; let __v_94: G = __v_22 * __v_87; let __v_95: G = __v_24 * __v_88; 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 = __v_90 + __v_99; let __v_101: G = __v_89 + __v_100; let __v_102: G = __v_81 + __v_101; if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_103: G = __v_88 - __v_33; let __v_104: G = __v_87 + __v_103; let __v_105: G = __v_86 + __v_104; let __v_106: G = __v_85 + __v_105; let __v_107: G = G::from_bool(__v_106 == G::ZERO); let __v_108: G = __v_83 + __v_84; let __v_109: G = __v_82 + __v_108; let __v_110: G = __v_81 + __v_109; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_43 - __v_111; let __v_113: G = __v_107 * __v_112; let __v_114: G = __v_43 - __v_113; if (__v_114 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_115: G = G::from_u8(__gb[0]); let __v_116: G = G::from_u8(__gb[1]); let __v_117: G = G::from_u8(__gb[2]); let __v_118: G = G::from_u8(__gb[3]); let __v_119: G = G::from_u8(__gb[4]); let __v_120: G = G::from_u8(__gb[5]); let __v_121: G = G::from_u8(__gb[6]); let __v_122: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_115; let __vj = __v_116; 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_117; let __vj = __v_118; 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_119; let __vj = __v_120; 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_121; let __vj = __v_122; 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_123: G = __v_12 * __v_116; let __v_124: G = __v_14 * __v_117; let __v_125: G = __v_16 * __v_118; let __v_126: G = __v_18 * __v_119; let __v_127: G = __v_20 * __v_120; let __v_128: G = __v_22 * __v_121; let __v_129: G = __v_24 * __v_122; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_127 + __v_130; let __v_132: G = __v_126 + __v_131; let __v_133: G = __v_125 + __v_132; let __v_134: G = __v_124 + __v_133; let __v_135: G = __v_123 + __v_134; let __v_136: G = __v_115 + __v_135; if (__v_136 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_137: G = __v_122 - __v_33; let __v_138: G = __v_121 + __v_137; let __v_139: G = __v_120 + __v_138; let __v_140: G = __v_119 + __v_139; let __v_141: G = G::from_bool(__v_140 == G::ZERO); let __v_142: G = __v_117 + __v_118; let __v_143: G = __v_116 + __v_142; let __v_144: G = __v_115 + __v_143; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_43 - __v_145; let __v_147: G = __v_141 * __v_146; let __v_148: G = __v_43 - __v_147; if (__v_148 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __v_149: G = G::from_u64(0); let __v_150: G = { let __values: [G; 10] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_151: G = { let __values: [G; 10] = [__v_149, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_150]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_152: G = { let __values: [G; 10] = [__v_149, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_151]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_153: G = { let __values: [G; 10] = [__v_149, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_152]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_154: G = { let __values: [G; 10] = [__v_149, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_153]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_153] = [__v_154]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_154: usize = 6; const IN_154: usize = 6; const OUT_154: usize = 3; -fn aiur_fn_154(inp: [G; IN_154], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_13: G = (__v_7 - __v_2); let __v_14: G = G::from_bool((__v_13 == G::ZERO)); match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = (__v_16 * __v_10); let __v_19: G = G::from_u64(7); let __v_20: G = (__v_17 * __v_11); let __v_21: G = (__v_19 * __v_20); let __v_22: G = (__v_18 + __v_21); let __v_23: G = (__v_16 * __v_11); let __v_24: G = (__v_17 * __v_10); 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_154] = [__v_26, __v_27, __v_12]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +fn aiur_fn_154(inp: [G; IN_154], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_13: G = __v_7 - __v_2; let __v_14: G = G::from_bool(__v_13 == G::ZERO); match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __v_16 * __v_10; let __v_19: G = G::from_u64(7); let __v_20: G = __v_17 * __v_11; let __v_21: G = __v_19 * __v_20; let __v_22: G = __v_18 + __v_21; let __v_23: G = __v_16 * __v_11; let __v_24: G = __v_17 * __v_10; 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_154] = [__v_26, __v_27, __v_12]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } const INPUT_SIZE_155: usize = 9; const IN_155: usize = 9; const OUT_155: usize = 3; -fn aiur_fn_155(inp: [G; IN_155], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { let __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_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, (&__args[..]))?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { (*(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245])) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_18: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_0, __v_1, __v_18]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; 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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = (__v_6 - __v_25); let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_11, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_23.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_0, __v_1, __v_28, __v_29]; }, _ => { break '__mc_0 [__v_28, __v_29, __v_0, __v_1]; }, } }; let __v_30: G = __mc_out___mc_0[0]; let __v_31: G = __mc_out___mc_0[1]; let __v_32: G = __mc_out___mc_0[2]; let __v_33: G = __mc_out___mc_0[3]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, (&__args[..]))?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { (*(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128])) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, (&__args[..]))?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { (*(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154])) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_36, __v_37, __v_16, __v_19, __v_12, __v_24, __v_26, __v_38, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, (&__args[..]))?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { (*(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155])) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); let __v_42: G = G::from_u8(__gb[0]); let __v_43: G = G::from_u8(__gb[1]); let __v_44: G = G::from_u8(__gb[2]); let __v_45: G = G::from_u8(__gb[3]); let __v_46: G = G::from_u8(__gb[4]); let __v_47: G = G::from_u8(__gb[5]); let __v_48: G = G::from_u8(__gb[6]); let __v_49: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_48; let __vj = __v_49; 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_50: G = G::from_u64(256); let __v_51: G = (__v_50 * __v_43); let __v_52: G = G::from_u64(65536); let __v_53: G = (__v_52 * __v_44); let __v_54: G = G::from_u64(16777216); let __v_55: G = (__v_54 * __v_45); let __v_56: G = G::from_u64(4294967296); let __v_57: G = (__v_56 * __v_46); let __v_58: G = G::from_u64(1099511627776); let __v_59: G = (__v_58 * __v_47); let __v_60: G = G::from_u64(281474976710656); let __v_61: G = (__v_60 * __v_48); let __v_62: G = G::from_u64(72057594037927936); let __v_63: G = (__v_62 * __v_49); let __v_64: G = (__v_61 + __v_63); let __v_65: G = (__v_59 + __v_64); let __v_66: G = (__v_57 + __v_65); let __v_67: G = (__v_55 + __v_66); let __v_68: G = (__v_53 + __v_67); let __v_69: G = (__v_51 + __v_68); let __v_70: G = (__v_42 + __v_69); if (__v_70 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __v_71: G = G::from_u64(1020); let __v_72: G = (__v_49 - __v_71); let __v_73: G = (__v_48 + __v_72); let __v_74: G = (__v_47 + __v_73); let __v_75: G = (__v_46 + __v_74); let __v_76: G = G::from_bool((__v_75 == G::ZERO)); let __v_77: G = (__v_44 + __v_45); let __v_78: G = (__v_43 + __v_77); let __v_79: G = (__v_42 + __v_78); let __v_80: G = G::from_bool((__v_79 == G::ZERO)); let __v_81: G = G::from_u64(1); let __v_82: G = (__v_81 - __v_80); let __v_83: G = (__v_76 * __v_82); let __v_84: G = (__v_81 - __v_83); if (__v_84 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); let __v_85: G = G::from_u8(__gb[0]); let __v_86: G = G::from_u8(__gb[1]); let __v_87: G = G::from_u8(__gb[2]); let __v_88: G = G::from_u8(__gb[3]); let __v_89: G = G::from_u8(__gb[4]); let __v_90: G = G::from_u8(__gb[5]); let __v_91: G = G::from_u8(__gb[6]); let __v_92: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; 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_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)); } let __v_93: G = (__v_50 * __v_86); let __v_94: G = (__v_52 * __v_87); let __v_95: G = (__v_54 * __v_88); let __v_96: G = (__v_56 * __v_89); let __v_97: G = (__v_58 * __v_90); let __v_98: G = (__v_60 * __v_91); let __v_99: G = (__v_62 * __v_92); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_97 + __v_100); let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_95 + __v_102); let __v_104: G = (__v_94 + __v_103); let __v_105: G = (__v_93 + __v_104); let __v_106: G = (__v_85 + __v_105); if (__v_106 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_106.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_107: G = (__v_92 - __v_71); let __v_108: G = (__v_91 + __v_107); let __v_109: G = (__v_90 + __v_108); let __v_110: G = (__v_89 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); let __v_112: G = (__v_87 + __v_88); let __v_113: G = (__v_86 + __v_112); let __v_114: G = (__v_85 + __v_113); let __v_115: G = G::from_bool((__v_114 == G::ZERO)); let __v_116: G = (__v_81 - __v_115); let __v_117: G = (__v_111 * __v_116); let __v_118: G = (__v_81 - __v_117); if (__v_118 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_118.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_119: G = G::from_u8(__gb[0]); let __v_120: G = G::from_u8(__gb[1]); let __v_121: G = G::from_u8(__gb[2]); let __v_122: G = G::from_u8(__gb[3]); let __v_123: G = G::from_u8(__gb[4]); let __v_124: G = G::from_u8(__gb[5]); let __v_125: G = G::from_u8(__gb[6]); let __v_126: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; 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_121; let __vj = __v_122; 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_123; let __vj = __v_124; 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_125; let __vj = __v_126; 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_127: G = (__v_50 * __v_120); let __v_128: G = (__v_52 * __v_121); let __v_129: G = (__v_54 * __v_122); let __v_130: G = (__v_56 * __v_123); let __v_131: G = (__v_58 * __v_124); let __v_132: G = (__v_60 * __v_125); let __v_133: G = (__v_62 * __v_126); let __v_134: G = (__v_132 + __v_133); let __v_135: G = (__v_131 + __v_134); let __v_136: G = (__v_130 + __v_135); let __v_137: G = (__v_129 + __v_136); let __v_138: G = (__v_128 + __v_137); let __v_139: G = (__v_127 + __v_138); let __v_140: G = (__v_119 + __v_139); if (__v_140 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_141: G = (__v_126 - __v_71); let __v_142: G = (__v_125 + __v_141); let __v_143: G = (__v_124 + __v_142); let __v_144: G = (__v_123 + __v_143); let __v_145: G = G::from_bool((__v_144 == G::ZERO)); let __v_146: G = (__v_121 + __v_122); let __v_147: G = (__v_120 + __v_146); let __v_148: G = (__v_119 + __v_147); let __v_149: G = G::from_bool((__v_148 == G::ZERO)); let __v_150: G = (__v_81 - __v_149); let __v_151: G = (__v_145 * __v_150); let __v_152: G = (__v_81 - __v_151); if (__v_152 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_33.as_canonical_u64().to_le_bytes(); let __v_153: G = G::from_u8(__gb[0]); let __v_154: G = G::from_u8(__gb[1]); let __v_155: G = G::from_u8(__gb[2]); let __v_156: G = G::from_u8(__gb[3]); let __v_157: G = G::from_u8(__gb[4]); let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_153; let __vj = __v_154; 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_155; let __vj = __v_156; 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_157; let __vj = __v_158; 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_159; let __vj = __v_160; 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_161: G = (__v_50 * __v_154); let __v_162: G = (__v_52 * __v_155); let __v_163: G = (__v_54 * __v_156); let __v_164: G = (__v_56 * __v_157); let __v_165: G = (__v_58 * __v_158); let __v_166: G = (__v_60 * __v_159); let __v_167: G = (__v_62 * __v_160); let __v_168: G = (__v_166 + __v_167); let __v_169: G = (__v_165 + __v_168); let __v_170: G = (__v_164 + __v_169); let __v_171: G = (__v_163 + __v_170); let __v_172: G = (__v_162 + __v_171); let __v_173: G = (__v_161 + __v_172); let __v_174: G = (__v_153 + __v_173); if (__v_174 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None }); } let __v_175: G = (__v_160 - __v_71); let __v_176: G = (__v_159 + __v_175); let __v_177: G = (__v_158 + __v_176); let __v_178: G = (__v_157 + __v_177); let __v_179: G = G::from_bool((__v_178 == G::ZERO)); let __v_180: G = (__v_155 + __v_156); let __v_181: G = (__v_154 + __v_180); let __v_182: G = (__v_153 + __v_181); let __v_183: G = G::from_bool((__v_182 == G::ZERO)); let __v_184: G = (__v_81 - __v_183); let __v_185: G = (__v_179 * __v_184); let __v_186: G = (__v_81 - __v_185); if (__v_186 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __v_187: G = G::from_u64(0); let __v_188: G = { let __values: [G; 10] = [__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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_189: G = { let __values: [G; 10] = [__v_187, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_188]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_190: G = { let __values: [G; 10] = [__v_187, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_189]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_191: G = { let __values: [G; 10] = [__v_187, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_190]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_192: G = { let __values: [G; 10] = [__v_187, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_191]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_193: G = { let __values: [G; 3] = [__v_187, __v_192, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_39, __v_40, __v_193]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +fn aiur_fn_155(inp: [G; IN_155], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { let __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_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, &__args[..])?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; 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 __v_18: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_0, __v_1, __v_18]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; 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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = __v_6 - __v_25; let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_11, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_23.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_0, __v_1, __v_28, __v_29]; }, _ => { break '__mc_0 [__v_28, __v_29, __v_0, __v_1]; }, } }; let __v_30: G = __mc_out___mc_0[0]; let __v_31: G = __mc_out___mc_0[1]; let __v_32: G = __mc_out___mc_0[2]; let __v_33: G = __mc_out___mc_0[3]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, &__args[..])?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, &__args[..])?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_36, __v_37, __v_16, __v_19, __v_12, __v_24, __v_26, __v_38, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, &__args[..])?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); let __v_42: G = G::from_u8(__gb[0]); let __v_43: G = G::from_u8(__gb[1]); let __v_44: G = G::from_u8(__gb[2]); let __v_45: G = G::from_u8(__gb[3]); let __v_46: G = G::from_u8(__gb[4]); let __v_47: G = G::from_u8(__gb[5]); let __v_48: G = G::from_u8(__gb[6]); let __v_49: G = G::from_u8(__gb[7]); 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); } if (!unconstrained) { let __vi = __v_48; let __vj = __v_49; 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_50: G = G::from_u64(256); let __v_51: G = __v_50 * __v_43; let __v_52: G = G::from_u64(65536); let __v_53: G = __v_52 * __v_44; let __v_54: G = G::from_u64(16777216); let __v_55: G = __v_54 * __v_45; let __v_56: G = G::from_u64(4294967296); let __v_57: G = __v_56 * __v_46; let __v_58: G = G::from_u64(1099511627776); let __v_59: G = __v_58 * __v_47; let __v_60: G = G::from_u64(281474976710656); let __v_61: G = __v_60 * __v_48; let __v_62: G = G::from_u64(72057594037927936); let __v_63: G = __v_62 * __v_49; let __v_64: G = __v_61 + __v_63; let __v_65: G = __v_59 + __v_64; let __v_66: G = __v_57 + __v_65; let __v_67: G = __v_55 + __v_66; let __v_68: G = __v_53 + __v_67; let __v_69: G = __v_51 + __v_68; let __v_70: G = __v_42 + __v_69; if (__v_70 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __v_71: G = G::from_u64(1020); let __v_72: G = __v_49 - __v_71; let __v_73: G = __v_48 + __v_72; let __v_74: G = __v_47 + __v_73; let __v_75: G = __v_46 + __v_74; let __v_76: G = G::from_bool(__v_75 == G::ZERO); let __v_77: G = __v_44 + __v_45; let __v_78: G = __v_43 + __v_77; let __v_79: G = __v_42 + __v_78; let __v_80: G = G::from_bool(__v_79 == G::ZERO); let __v_81: G = G::from_u64(1); let __v_82: G = __v_81 - __v_80; let __v_83: G = __v_76 * __v_82; let __v_84: G = __v_81 - __v_83; if (__v_84 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); let __v_85: G = G::from_u8(__gb[0]); let __v_86: G = G::from_u8(__gb[1]); let __v_87: G = G::from_u8(__gb[2]); let __v_88: G = G::from_u8(__gb[3]); let __v_89: G = G::from_u8(__gb[4]); let __v_90: G = G::from_u8(__gb[5]); let __v_91: G = G::from_u8(__gb[6]); let __v_92: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; 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_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); } let __v_93: G = __v_50 * __v_86; let __v_94: G = __v_52 * __v_87; let __v_95: G = __v_54 * __v_88; let __v_96: G = __v_56 * __v_89; let __v_97: G = __v_58 * __v_90; let __v_98: G = __v_60 * __v_91; let __v_99: G = __v_62 * __v_92; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_97 + __v_100; let __v_102: G = __v_96 + __v_101; let __v_103: G = __v_95 + __v_102; let __v_104: G = __v_94 + __v_103; let __v_105: G = __v_93 + __v_104; let __v_106: G = __v_85 + __v_105; if (__v_106 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_106.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_107: G = __v_92 - __v_71; let __v_108: G = __v_91 + __v_107; let __v_109: G = __v_90 + __v_108; let __v_110: G = __v_89 + __v_109; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_87 + __v_88; let __v_113: G = __v_86 + __v_112; let __v_114: G = __v_85 + __v_113; let __v_115: G = G::from_bool(__v_114 == G::ZERO); let __v_116: G = __v_81 - __v_115; let __v_117: G = __v_111 * __v_116; let __v_118: G = __v_81 - __v_117; if (__v_118 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_118.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_119: G = G::from_u8(__gb[0]); let __v_120: G = G::from_u8(__gb[1]); let __v_121: G = G::from_u8(__gb[2]); let __v_122: G = G::from_u8(__gb[3]); let __v_123: G = G::from_u8(__gb[4]); let __v_124: G = G::from_u8(__gb[5]); let __v_125: G = G::from_u8(__gb[6]); let __v_126: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; 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_121; let __vj = __v_122; 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_123; let __vj = __v_124; 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_125; let __vj = __v_126; 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_127: G = __v_50 * __v_120; let __v_128: G = __v_52 * __v_121; let __v_129: G = __v_54 * __v_122; let __v_130: G = __v_56 * __v_123; let __v_131: G = __v_58 * __v_124; let __v_132: G = __v_60 * __v_125; let __v_133: G = __v_62 * __v_126; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_131 + __v_134; let __v_136: G = __v_130 + __v_135; let __v_137: G = __v_129 + __v_136; let __v_138: G = __v_128 + __v_137; let __v_139: G = __v_127 + __v_138; let __v_140: G = __v_119 + __v_139; if (__v_140 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_141: G = __v_126 - __v_71; let __v_142: G = __v_125 + __v_141; let __v_143: G = __v_124 + __v_142; let __v_144: G = __v_123 + __v_143; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_121 + __v_122; let __v_147: G = __v_120 + __v_146; let __v_148: G = __v_119 + __v_147; let __v_149: G = G::from_bool(__v_148 == G::ZERO); let __v_150: G = __v_81 - __v_149; let __v_151: G = __v_145 * __v_150; let __v_152: G = __v_81 - __v_151; if (__v_152 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_33.as_canonical_u64().to_le_bytes(); let __v_153: G = G::from_u8(__gb[0]); let __v_154: G = G::from_u8(__gb[1]); let __v_155: G = G::from_u8(__gb[2]); let __v_156: G = G::from_u8(__gb[3]); let __v_157: G = G::from_u8(__gb[4]); let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_153; let __vj = __v_154; 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_155; let __vj = __v_156; 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_157; let __vj = __v_158; 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_159; let __vj = __v_160; 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_161: G = __v_50 * __v_154; let __v_162: G = __v_52 * __v_155; let __v_163: G = __v_54 * __v_156; let __v_164: G = __v_56 * __v_157; let __v_165: G = __v_58 * __v_158; let __v_166: G = __v_60 * __v_159; let __v_167: G = __v_62 * __v_160; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_165 + __v_168; let __v_170: G = __v_164 + __v_169; let __v_171: G = __v_163 + __v_170; let __v_172: G = __v_162 + __v_171; let __v_173: G = __v_161 + __v_172; let __v_174: G = __v_153 + __v_173; if (__v_174 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None }); } let __v_175: G = __v_160 - __v_71; let __v_176: G = __v_159 + __v_175; let __v_177: G = __v_158 + __v_176; let __v_178: G = __v_157 + __v_177; let __v_179: G = G::from_bool(__v_178 == G::ZERO); let __v_180: G = __v_155 + __v_156; let __v_181: G = __v_154 + __v_180; let __v_182: G = __v_153 + __v_181; let __v_183: G = G::from_bool(__v_182 == G::ZERO); let __v_184: G = __v_81 - __v_183; let __v_185: G = __v_179 * __v_184; let __v_186: G = __v_81 - __v_185; if (__v_186 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __v_187: G = G::from_u64(0); let __v_188: G = { let __values: [G; 10] = [__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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_189: G = { let __values: [G; 10] = [__v_187, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_188]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_190: G = { let __values: [G; 10] = [__v_187, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_189]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_191: G = { let __values: [G; 10] = [__v_187, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_190]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_192: G = { let __values: [G; 10] = [__v_187, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_191]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_193: G = { let __values: [G; 3] = [__v_187, __v_192, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_39, __v_40, __v_193]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_156: usize = 25; const IN_156: usize = 25; const OUT_156: usize = 1; -fn aiur_fn_156(inp: [G; IN_156], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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]; match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_24); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_30 + __v_31); let __v_33: G = (__v_29 - __v_32); let __v_34: G = G::from_bool((__v_33 == G::ZERO)); if (__v_34 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_15, __v_19, __v_18, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_39 - __v_18); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_43: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_35, __v_0, __v_20, __v_19, __v_43, __v_18, __v_15, __v_16, __v_17, __v_38, __v_5, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_46 - __v_18); let __v_48: G = G::from_bool((__v_47 == G::ZERO)); let __v_49: G = G::from_u64(1); if (__v_48 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None }); } let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_44, __v_0, __v_20, __v_19, __v_50, __v_18, __v_15, __v_16, __v_17, __v_45, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_54 - __v_18); let __v_56: G = G::from_bool((__v_55 == G::ZERO)); let __v_57: G = G::from_u64(1); if (__v_56 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None }); } let __v_58: G = G::from_u64(0); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_51, __v_0, __v_20, __v_19, __v_58, __v_18, __v_15, __v_16, __v_17, __v_53, __v_7, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, (&__args[..]))?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { (*(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146])) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_59, __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 ((!unconstrained) && record.defer_call(148, (&__args[..]))?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { (*(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148])) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_60, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_62: G = __loaded[0]; let __v_63: G = __loaded[1]; let __v_64: G = __loaded[2]; let __v_65: G = __loaded[3]; let __v_66: G = __loaded[4]; let __v_67: G = __loaded[5]; let __v_68: G = __loaded[6]; match __v_62.as_canonical_u64() { 0u64 => { match __v_63.as_canonical_u64() { _ => { let __v_69: G = (__v_63 - __v_20); 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_155] = { let __args: [G; IN_155] = [__v_66, __v_67, __v_21, __v_22, __v_2, __v_0, __v_20, __v_68, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, (&__args[..]))?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { (*(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155])) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_23, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = (__v_76 - __v_72); let __v_79: G = G::from_bool((__v_78 == G::ZERO)); let __v_80: G = (__v_77 - __v_73); let __v_81: G = G::from_bool((__v_80 == G::ZERO)); let __v_82: G = (__v_79 * __v_81); if (__v_82 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_156] = [__v_74]; record.function_queries[156].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } +fn aiur_fn_156(inp: [G; IN_156], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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]; match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __v_25 - __v_24; let __v_27: G = G::from_bool(__v_26 == G::ZERO); 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __v_30 + __v_31; let __v_33: G = __v_29 - __v_32; let __v_34: G = G::from_bool(__v_33 == G::ZERO); if (__v_34 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_15, __v_19, __v_18, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __v_39 - __v_18; let __v_41: G = G::from_bool(__v_40 == G::ZERO); let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_43: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_35, __v_0, __v_20, __v_19, __v_43, __v_18, __v_15, __v_16, __v_17, __v_38, __v_5, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __v_46 - __v_18; let __v_48: G = G::from_bool(__v_47 == G::ZERO); let __v_49: G = G::from_u64(1); if (__v_48 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None }); } let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_44, __v_0, __v_20, __v_19, __v_50, __v_18, __v_15, __v_16, __v_17, __v_45, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __v_54 - __v_18; let __v_56: G = G::from_bool(__v_55 == G::ZERO); let __v_57: G = G::from_u64(1); if (__v_56 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None }); } let __v_58: G = G::from_u64(0); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_51, __v_0, __v_20, __v_19, __v_58, __v_18, __v_15, __v_16, __v_17, __v_53, __v_7, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, &__args[..])?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_59, __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 ((!unconstrained) && record.defer_call(148, &__args[..])?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_60, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, &__args[..])?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_62: G = __loaded[0]; let __v_63: G = __loaded[1]; let __v_64: G = __loaded[2]; let __v_65: G = __loaded[3]; let __v_66: G = __loaded[4]; let __v_67: G = __loaded[5]; let __v_68: G = __loaded[6]; match __v_62.as_canonical_u64() { 0u64 => { match __v_63.as_canonical_u64() { _ => { let __v_69: G = __v_63 - __v_20; 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_155] = { let __args: [G; IN_155] = [__v_66, __v_67, __v_21, __v_22, __v_2, __v_0, __v_20, __v_68, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, &__args[..])?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_23, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = __v_76 - __v_72; let __v_79: G = G::from_bool(__v_78 == G::ZERO); let __v_80: G = __v_77 - __v_73; let __v_81: G = G::from_bool(__v_80 == G::ZERO); let __v_82: G = __v_79 * __v_81; if (__v_82 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_156] = [__v_74]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } const INPUT_SIZE_157: usize = 25; const IN_157: usize = 25; const OUT_157: usize = 1; -fn aiur_fn_157(inp: [G; IN_157], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_30]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; 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_156] = { let __args: [G; IN_156] = [__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 ((!unconstrained) && record.defer_call(156, (&__args[..]))?) { [G::ZERO; OUT_156] } else { let (__hash, __hit) = record.function_queries[156].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[156].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { (*(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156])) }; __ret }, _ => { aiur_fn_156::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__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 ((!unconstrained) && record.defer_call(157, (&__args[..]))?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { (*(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157])) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_35]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } +fn aiur_fn_157(inp: [G; IN_157], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_30]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; 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_156] = { let __args: [G; IN_156] = [__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 ((!unconstrained) && record.defer_call(156, &__args[..])?) { [G::ZERO; OUT_156] } else { let (__hash, __hit) = record.function_queries[156].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[156].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => { aiur_fn_156::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__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 ((!unconstrained) && record.defer_call(157, &__args[..])?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_35]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } const INPUT_SIZE_158: usize = 4; const IN_158: usize = 4; const OUT_158: usize = 1; -fn aiur_fn_158(inp: [G; IN_158], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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 = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_5]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; 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_158] = { let __args: [G; IN_158] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_11]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_158(inp: [G; IN_158], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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 = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_5]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; 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_158] = { let __args: [G; IN_158] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_11]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_159: usize = 2; const IN_159: usize = 2; const OUT_159: usize = 1; -fn aiur_fn_159(inp: [G; IN_159], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_7]; record.function_queries[159].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, (&__args[..]))?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { (*(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159])) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_9]; record.function_queries[159].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_159(inp: [G; IN_159], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_7]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, &__args[..])?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_9]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_160: usize = 2; const IN_160: usize = 2; const OUT_160: usize = 1; -fn aiur_fn_160(inp: [G; IN_160], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_8]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, (&__args[..]))?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { (*(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160])) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_10]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_160(inp: [G; IN_160], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_8]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, &__args[..])?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_10]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_161: usize = 4; const IN_161: usize = 4; const OUT_161: usize = 1; -fn aiur_fn_161(inp: [G; IN_161], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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 = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_5]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, (&__args[..]))?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { (*(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159])) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, (&__args[..]))?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { (*(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160])) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; 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 = (__v_3 - __v_7); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_11]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_161(inp: [G; IN_161], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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 = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_5]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, &__args[..])?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, &__args[..])?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; 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 = __v_3 - __v_7; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_11]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_162: usize = 13; const IN_162: usize = 13; const OUT_162: usize = 1; -fn aiur_fn_162(inp: [G; IN_162], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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_149] = { let __args: [G; IN_149] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_6.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_162] = [__v_27]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_9, __v_11, __v_8, __v_10, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_12 - __v_32); let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_35]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } +fn aiur_fn_162(inp: [G; IN_162], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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_149] = { let __args: [G; IN_149] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_6.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_162] = [__v_27]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_9, __v_11, __v_8, __v_10, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __v_12 - __v_32; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_35]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } const INPUT_SIZE_163: usize = 2; const IN_163: usize = 2; const OUT_163: usize = 1; -fn aiur_fn_163(inp: [G; IN_163], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_163] = [__v_0]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_8]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_163(inp: [G; IN_163], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_163] = [__v_0]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_8]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_164: usize = 2; const IN_164: usize = 2; const OUT_164: usize = 1; -fn aiur_fn_164(inp: [G; IN_164], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_6]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_5, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_164(inp: [G; IN_164], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_6]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, &__args[..])?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_5, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_165: usize = 6; const IN_165: usize = 6; const OUT_165: usize = 1; -fn aiur_fn_165(inp: [G; IN_165], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_bool((__v_11 == G::ZERO)); let __ret: [G; OUT_165] = [__v_12]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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); if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_14); let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_18, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_24: G = (__v_4 + __v_14); let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_25]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +fn aiur_fn_165(inp: [G; IN_165], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_bool(__v_11 == G::ZERO); let __ret: [G; OUT_165] = [__v_12]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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); if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_5 - __v_14; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, &__args[..])?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_18, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_24: G = __v_4 + __v_14; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_25]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } const INPUT_SIZE_166: usize = 32; const IN_166: usize = 32; const OUT_166: usize = 1; -fn aiur_fn_166(inp: [G; IN_166], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = (__v_33 - __v_32); let __v_35: G = G::from_bool((__v_34 == G::ZERO)); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_38 + __v_39); if (__v_37 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, (&__args[..]))?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { (*(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252])) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_41 - __v_32); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); if (__v_43 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; if (__v_44 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __v_45: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_45]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; break '__mc_0 [__v_46]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; let __v_46: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 3] = [__v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_50, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __v_71: G = G::from_u64(256); let __v_72: G = (__v_71 * __v_54); let __v_73: G = G::from_u64(65536); let __v_74: G = (__v_73 * __v_55); let __v_75: G = G::from_u64(16777216); let __v_76: G = (__v_75 * __v_56); let __v_77: G = G::from_u64(4294967296); let __v_78: G = (__v_77 * __v_57); let __v_79: G = G::from_u64(1099511627776); let __v_80: G = (__v_79 * __v_58); let __v_81: G = G::from_u64(281474976710656); let __v_82: G = (__v_81 * __v_59); let __v_83: G = G::from_u64(72057594037927936); let __v_84: G = (__v_83 * __v_60); let __v_85: G = (__v_82 + __v_84); let __v_86: G = (__v_80 + __v_85); let __v_87: G = (__v_78 + __v_86); let __v_88: G = (__v_76 + __v_87); let __v_89: G = (__v_74 + __v_88); let __v_90: G = (__v_72 + __v_89); let __v_91: G = (__v_53 + __v_90); let __v_92: G = (__v_71 * __v_62); let __v_93: G = (__v_73 * __v_63); let __v_94: G = (__v_75 * __v_64); let __v_95: G = (__v_77 * __v_65); let __v_96: G = (__v_79 * __v_66); let __v_97: G = (__v_81 * __v_67); let __v_98: G = (__v_83 * __v_68); let __v_99: G = (__v_97 + __v_98); let __v_100: G = (__v_96 + __v_99); let __v_101: G = (__v_95 + __v_100); let __v_102: G = (__v_94 + __v_101); let __v_103: G = (__v_93 + __v_102); let __v_104: G = (__v_92 + __v_103); let __v_105: G = (__v_61 + __v_104); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_69, __v_6, __v_7, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, (&__args[..]))?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { (*(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137])) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_10, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_109, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_110: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = (__v_32 + __v_28); let __v_114: G = G::from_u64(33); let __v_115: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_114.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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; if (__v_115 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_111, __v_112, __v_29, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_116: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_116, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, (&__args[..]))?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { (*(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162])) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_117: G = __r_arr[0]; if (__v_117 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __v_118: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_8, __v_9, __v_118, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_111, __v_112, __v_119, __v_91, __v_105, __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_113, __v_106, __v_6, __v_10, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, (&__args[..]))?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { (*(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157])) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_120: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_121: G = __r_arr[0]; let __ret: [G; OUT_166] = [__v_121]; record.function_queries[166].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_166(inp: [G; IN_166], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __v_33 - __v_32; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __v_38 + __v_39; if (__v_37 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, &__args[..])?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __v_41 - __v_32; let __v_43: G = G::from_bool(__v_42 == G::ZERO); if (__v_43 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; if (__v_44 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __v_45: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_45]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; break '__mc_0 [__v_46]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; let __v_46: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 3] = [__v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_50, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __v_71: G = G::from_u64(256); let __v_72: G = __v_71 * __v_54; let __v_73: G = G::from_u64(65536); let __v_74: G = __v_73 * __v_55; let __v_75: G = G::from_u64(16777216); let __v_76: G = __v_75 * __v_56; let __v_77: G = G::from_u64(4294967296); let __v_78: G = __v_77 * __v_57; let __v_79: G = G::from_u64(1099511627776); let __v_80: G = __v_79 * __v_58; let __v_81: G = G::from_u64(281474976710656); let __v_82: G = __v_81 * __v_59; let __v_83: G = G::from_u64(72057594037927936); let __v_84: G = __v_83 * __v_60; let __v_85: G = __v_82 + __v_84; let __v_86: G = __v_80 + __v_85; let __v_87: G = __v_78 + __v_86; let __v_88: G = __v_76 + __v_87; let __v_89: G = __v_74 + __v_88; let __v_90: G = __v_72 + __v_89; let __v_91: G = __v_53 + __v_90; let __v_92: G = __v_71 * __v_62; let __v_93: G = __v_73 * __v_63; let __v_94: G = __v_75 * __v_64; let __v_95: G = __v_77 * __v_65; let __v_96: G = __v_79 * __v_66; let __v_97: G = __v_81 * __v_67; let __v_98: G = __v_83 * __v_68; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_96 + __v_99; let __v_101: G = __v_95 + __v_100; let __v_102: G = __v_94 + __v_101; let __v_103: G = __v_93 + __v_102; let __v_104: G = __v_92 + __v_103; let __v_105: G = __v_61 + __v_104; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_69, __v_6, __v_7, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, &__args[..])?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_10, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_109, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_110: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = __v_32 + __v_28; let __v_114: G = G::from_u64(33); let __v_115: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_114.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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; if (__v_115 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_111, __v_112, __v_29, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_116: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_116, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, &__args[..])?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_117: G = __r_arr[0]; if (__v_117 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __v_118: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_8, __v_9, __v_118, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_111, __v_112, __v_119, __v_91, __v_105, __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_113, __v_106, __v_6, __v_10, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, &__args[..])?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_120: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_121: G = __r_arr[0]; let __ret: [G; OUT_166] = [__v_121]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_167: usize = 2; const IN_167: usize = 2; const OUT_167: usize = 1; -fn aiur_fn_167(inp: [G; IN_167], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_167] = [__v_4]; record.function_queries[167].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_167(inp: [G; IN_167], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_167] = [__v_4]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_168: usize = 9; const IN_168: usize = 9; const OUT_168: usize = 1; -fn aiur_fn_168(inp: [G; IN_168], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 3] = [__v_9, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 3] = [__v_9, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_9, __v_1, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_0, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_168] = [__v_17]; record.function_queries[168].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_168(inp: [G; IN_168], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 3] = [__v_9, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 3] = [__v_9, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_9, __v_1, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_0, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_168] = [__v_17]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_169: usize = 33; const IN_169: usize = 33; const OUT_169: usize = 1; -fn aiur_fn_169(inp: [G; IN_169], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; 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_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_36]; record.function_queries[169].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_169(inp: [G; IN_169], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; 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_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_36]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_170: usize = 2; const IN_170: usize = 2; const OUT_170: usize = 1; -fn aiur_fn_170(inp: [G; IN_170], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_170] = [__v_1]; record.function_queries[170].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; let __v_23: G = __loaded[18]; let __v_24: G = __loaded[19]; let __v_25: G = __loaded[20]; let __v_26: G = __loaded[21]; let __v_27: G = __loaded[22]; let __v_28: G = __loaded[23]; let __v_29: G = __loaded[24]; let __v_30: G = __loaded[25]; let __v_31: G = __loaded[26]; let __v_32: G = __loaded[27]; let __v_33: G = __loaded[28]; let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_41]; record.function_queries[170].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_170(inp: [G; IN_170], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_170] = [__v_1]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; let __v_23: G = __loaded[18]; let __v_24: G = __loaded[19]; let __v_25: G = __loaded[20]; let __v_26: G = __loaded[21]; let __v_27: G = __loaded[22]; let __v_28: G = __loaded[23]; let __v_29: G = __loaded[24]; let __v_30: G = __loaded[25]; let __v_31: G = __loaded[26]; let __v_32: G = __loaded[27]; let __v_33: G = __loaded[28]; let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_41]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_171: usize = 2; const IN_171: usize = 2; const OUT_171: usize = 1; -fn aiur_fn_171(inp: [G; IN_171], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_171] = [__v_1]; record.function_queries[171].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_7]; record.function_queries[171].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_171(inp: [G; IN_171], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_171] = [__v_1]; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_7]; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_172: usize = 2; const IN_172: usize = 2; const OUT_172: usize = 10; -fn aiur_fn_172(inp: [G; IN_172], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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(103); let __v_6: G = G::from_u64(230); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(106); let __v_9: G = G::from_u64(133); let __v_10: G = G::from_u64(174); let __v_11: G = G::from_u64(187); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(243); let __v_14: G = G::from_u64(110); let __v_15: G = G::from_u64(60); let __v_16: G = G::from_u64(58); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(165); let __v_20: G = G::from_u64(127); let __v_21: G = G::from_u64(82); let __v_22: G = G::from_u64(14); let __v_23: G = G::from_u64(81); let __v_24: G = G::from_u64(140); let __v_25: G = G::from_u64(104); let __v_26: G = G::from_u64(5); let __v_27: G = G::from_u64(155); let __v_28: G = G::from_u64(171); let __v_29: G = G::from_u64(217); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(31); let __v_32: G = G::from_u64(25); let __v_33: G = G::from_u64(205); let __v_34: G = G::from_u64(224); let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 8] = [__v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 34] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_37, __v_38, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; 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 = __r_arr[18]; let __v_62: G = __r_arr[19]; let __v_63: G = __r_arr[20]; let __v_64: G = __r_arr[21]; let __v_65: G = __r_arr[22]; let __v_66: G = __r_arr[23]; let __v_67: G = __r_arr[24]; let __v_68: G = __r_arr[25]; let __v_69: G = __r_arr[26]; let __v_70: G = __r_arr[27]; let __v_71: G = __r_arr[28]; let __v_72: G = __r_arr[29]; let __v_73: G = __r_arr[30]; let __v_74: G = __r_arr[31]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_71, __v_72, __v_73, __v_74, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_67, __v_68, __v_69, __v_70, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_63, __v_64, __v_65, __v_66, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_59, __v_60, __v_61, __v_62, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_55, __v_56, __v_57, __v_58, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_51, __v_52, __v_53, __v_54, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48, __v_49, __v_50, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_43, __v_44, __v_45, __v_46, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_82, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_83.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; match __v_84.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; match __v_87.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_89.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_90: G = __loaded[0]; let __v_91: G = __loaded[1]; let __v_92: G = __loaded[2]; match __v_90.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; match __v_93.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_95.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_96: G = __loaded[0]; let __v_97: G = __loaded[1]; let __v_98: G = __loaded[2]; match __v_96.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_99: G = __loaded[0]; let __v_100: G = __loaded[1]; let __v_101: G = __loaded[2]; match __v_99.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_101.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_102: G = __loaded[0]; let __v_103: G = __loaded[1]; let __v_104: G = __loaded[2]; match __v_102.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_105: G = __loaded[0]; let __v_106: G = __loaded[1]; let __v_107: G = __loaded[2]; match __v_105.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[172].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_105.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_99.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_96.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_93.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_90.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_87.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_84.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; 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 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[172].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.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_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_172(inp: [G; IN_172], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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(103); let __v_6: G = G::from_u64(230); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(106); let __v_9: G = G::from_u64(133); let __v_10: G = G::from_u64(174); let __v_11: G = G::from_u64(187); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(243); let __v_14: G = G::from_u64(110); let __v_15: G = G::from_u64(60); let __v_16: G = G::from_u64(58); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(165); let __v_20: G = G::from_u64(127); let __v_21: G = G::from_u64(82); let __v_22: G = G::from_u64(14); let __v_23: G = G::from_u64(81); let __v_24: G = G::from_u64(140); let __v_25: G = G::from_u64(104); let __v_26: G = G::from_u64(5); let __v_27: G = G::from_u64(155); let __v_28: G = G::from_u64(171); let __v_29: G = G::from_u64(217); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(31); let __v_32: G = G::from_u64(25); let __v_33: G = G::from_u64(205); let __v_34: G = G::from_u64(224); let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 8] = [__v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 34] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_37, __v_38, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; 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 = __r_arr[18]; let __v_62: G = __r_arr[19]; let __v_63: G = __r_arr[20]; let __v_64: G = __r_arr[21]; let __v_65: G = __r_arr[22]; let __v_66: G = __r_arr[23]; let __v_67: G = __r_arr[24]; let __v_68: G = __r_arr[25]; let __v_69: G = __r_arr[26]; let __v_70: G = __r_arr[27]; let __v_71: G = __r_arr[28]; let __v_72: G = __r_arr[29]; let __v_73: G = __r_arr[30]; let __v_74: G = __r_arr[31]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_71, __v_72, __v_73, __v_74, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_67, __v_68, __v_69, __v_70, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_63, __v_64, __v_65, __v_66, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_59, __v_60, __v_61, __v_62, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_55, __v_56, __v_57, __v_58, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_51, __v_52, __v_53, __v_54, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48, __v_49, __v_50, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_43, __v_44, __v_45, __v_46, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_82, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_83.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; match __v_84.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; match __v_87.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_89.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_90: G = __loaded[0]; let __v_91: G = __loaded[1]; let __v_92: G = __loaded[2]; match __v_90.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; match __v_93.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_95.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_96: G = __loaded[0]; let __v_97: G = __loaded[1]; let __v_98: G = __loaded[2]; match __v_96.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_99: G = __loaded[0]; let __v_100: G = __loaded[1]; let __v_101: G = __loaded[2]; match __v_99.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_101.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_102: G = __loaded[0]; let __v_103: G = __loaded[1]; let __v_104: G = __loaded[2]; match __v_102.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_105: G = __loaded[0]; let __v_106: G = __loaded[1]; let __v_107: G = __loaded[2]; match __v_105.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_105.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_99.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_96.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_93.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_90.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_87.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_84.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; 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 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.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_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_173: usize = 2; const IN_173: usize = 2; const OUT_173: usize = 10; -fn aiur_fn_173(inp: [G; IN_173], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, (&__args[..]))?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { (*(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172])) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1020); let __v_13: G = (__v_9 - __v_12); let __v_14: G = (__v_8 + __v_13); let __v_15: G = (__v_7 + __v_14); let __v_16: G = (__v_6 + __v_15); let __v_17: G = G::from_bool((__v_16 == G::ZERO)); let __v_18: G = (__v_4 + __v_5); let __v_19: G = (__v_3 + __v_18); let __v_20: G = (__v_2 + __v_19); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); let __v_22: G = G::from_u64(1); let __v_23: G = (__v_22 - __v_21); let __v_24: G = (__v_17 * __v_23); let __v_25: G = (__v_22 - __v_24); match __v_25.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_173] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = __r_arr[9]; let __ret: [G; OUT_173] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_173(inp: [G; IN_173], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, &__args[..])?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1020); let __v_13: G = __v_9 - __v_12; let __v_14: G = __v_8 + __v_13; let __v_15: G = __v_7 + __v_14; let __v_16: G = __v_6 + __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = __v_4 + __v_5; let __v_19: G = __v_3 + __v_18; let __v_20: G = __v_2 + __v_19; let __v_21: G = G::from_bool(__v_20 == G::ZERO); let __v_22: G = G::from_u64(1); let __v_23: G = __v_22 - __v_21; let __v_24: G = __v_17 * __v_23; let __v_25: G = __v_22 - __v_24; match __v_25.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_173] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = __r_arr[9]; let __ret: [G; OUT_173] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_174: usize = 2; const IN_174: usize = 2; const OUT_174: usize = 18; -fn aiur_fn_174(inp: [G; IN_174], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_174] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[174].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_174(inp: [G; IN_174], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_174] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_175: usize = 2; const IN_175: usize = 2; const OUT_175: usize = 1; -fn aiur_fn_175(inp: [G; IN_175], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_3]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, (&__args[..]))?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { (*(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175])) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_9]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_175(inp: [G; IN_175], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_3]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, &__args[..])?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_9]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_176: usize = 3; const IN_176: usize = 3; const OUT_176: usize = 3; -fn aiur_fn_176(inp: [G; IN_176], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, (&__args[..]))?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { (*(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172])) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_3)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_3, record) }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; let __v_16: G = __b1_out[3]; let __v_17: G = __b1_out[4]; let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_4)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_4, record) }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; let __v_24: G = __b1_out[3]; let __v_25: G = __b1_out[4]; let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_5)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_5, record) }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; let __v_32: G = __b1_out[3]; let __v_33: G = __b1_out[4]; let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_6)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_6, record) }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; let __v_40: G = __b1_out[3]; let __v_41: G = __b1_out[4]; let __v_42: G = __b1_out[5]; let __v_43: G = __b1_out[6]; let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_50, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, (&__args[..]))?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { (*(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175])) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_51, __v_11, __v_12]; record.function_queries[176].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_176(inp: [G; IN_176], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, &__args[..])?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_3, record) }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; let __v_16: G = __b1_out[3]; let __v_17: G = __b1_out[4]; let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_4, record) }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; let __v_24: G = __b1_out[3]; let __v_25: G = __b1_out[4]; let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_5, record) }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; let __v_32: G = __b1_out[3]; let __v_33: G = __b1_out[4]; let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_6, record) }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; let __v_40: G = __b1_out[3]; let __v_41: G = __b1_out[4]; let __v_42: G = __b1_out[5]; let __v_43: G = __b1_out[6]; let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_50, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, &__args[..])?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_51, __v_11, __v_12]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_177: usize = 9; const IN_177: usize = 9; const OUT_177: usize = 1; -fn aiur_fn_177(inp: [G; IN_177], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_177] = [__v_12]; record.function_queries[177].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_177(inp: [G; IN_177], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_177] = [__v_12]; record.function_queries[177].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_178: usize = 2; const IN_178: usize = 2; const OUT_178: usize = 1; -fn aiur_fn_178(inp: [G; IN_178], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_178] = [__v_5]; record.function_queries[178].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_178(inp: [G; IN_178], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_178] = [__v_5]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_179: usize = 1; const IN_179: usize = 1; const OUT_179: usize = 1; -fn aiur_fn_179(inp: [G; IN_179], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(117); let __v_4: G = G::from_u64(108); let __v_5: G = G::from_u64(116); let __v_6: G = G::from_u64(105); let __v_7: G = G::from_u64(45); let __v_8: G = G::from_u64(115); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(114); let __v_11: G = G::from_u64(107); let __v_12: G = G::from_u64(47); let __v_13: G = G::from_u64(118); let __v_14: G = G::from_u64(48); let __v_15: G = { let __values: [G; 3] = [__v_1, __v_14, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_1, __v_13, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_1, __v_12, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 3] = [__v_1, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_10, __v_18]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_20: G = { let __values: [G; 3] = [__v_1, __v_9, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_21: G = { let __values: [G; 3] = [__v_1, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_1, __v_8, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_23: G = { let __values: [G; 3] = [__v_1, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_24: G = { let __values: [G; 3] = [__v_1, __v_6, __v_23]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_25: G = { let __values: [G; 3] = [__v_1, __v_5, __v_24]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_26: G = { let __values: [G; 3] = [__v_1, __v_4, __v_25]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_1, __v_3, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_1, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_179] = [__v_28]; record.function_queries[179].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_179(inp: [G; IN_179], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(117); let __v_4: G = G::from_u64(108); let __v_5: G = G::from_u64(116); let __v_6: G = G::from_u64(105); let __v_7: G = G::from_u64(45); let __v_8: G = G::from_u64(115); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(114); let __v_11: G = G::from_u64(107); let __v_12: G = G::from_u64(47); let __v_13: G = G::from_u64(118); let __v_14: G = G::from_u64(48); let __v_15: G = { let __values: [G; 3] = [__v_1, __v_14, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_1, __v_13, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_1, __v_12, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 3] = [__v_1, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_10, __v_18]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_20: G = { let __values: [G; 3] = [__v_1, __v_9, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_21: G = { let __values: [G; 3] = [__v_1, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_1, __v_8, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_23: G = { let __values: [G; 3] = [__v_1, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_24: G = { let __values: [G; 3] = [__v_1, __v_6, __v_23]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_25: G = { let __values: [G; 3] = [__v_1, __v_5, __v_24]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_26: G = { let __values: [G; 3] = [__v_1, __v_4, __v_25]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_1, __v_3, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_1, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_179] = [__v_28]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_180: usize = 2; const IN_180: usize = 2; const OUT_180: usize = 1; -fn aiur_fn_180(inp: [G; IN_180], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_180] = [__v_1]; record.function_queries[180].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_180] = [__v_13]; record.function_queries[180].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_180(inp: [G; IN_180], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_180] = [__v_1]; record.function_queries[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_180] = [__v_13]; record.function_queries[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_181: usize = 2; const IN_181: usize = 2; const OUT_181: usize = 1; -fn aiur_fn_181(inp: [G; IN_181], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_181] = [__v_3]; record.function_queries[181].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_181] = [__v_1]; record.function_queries[181].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_181(inp: [G; IN_181], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_181] = [__v_3]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_181] = [__v_1]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_182: usize = 3; const IN_182: usize = 3; const OUT_182: usize = 2; -fn aiur_fn_182(inp: [G; IN_182], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_182] = [__v_0, __v_1]; record.function_queries[182].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = (__v_0 * __v_0); let __v_4: G = G::from_u64(7); let __v_5: G = (__v_1 * __v_1); let __v_6: G = (__v_4 * __v_5); let __v_7: G = (__v_3 + __v_6); let __v_8: G = (__v_0 * __v_1); let __v_9: G = (__v_1 * __v_0); 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_182] = { let __args: [G; IN_182] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_13, __v_14]; record.function_queries[182].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_182(inp: [G; IN_182], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_182] = [__v_0, __v_1]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = __v_0 * __v_0; let __v_4: G = G::from_u64(7); let __v_5: G = __v_1 * __v_1; let __v_6: G = __v_4 * __v_5; let __v_7: G = __v_3 + __v_6; let __v_8: G = __v_0 * __v_1; let __v_9: G = __v_1 * __v_0; 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_182] = { let __args: [G; IN_182] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_13, __v_14]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_183] = [__v_1]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 + __v_1); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_3 * __v_3); let __ret: [G; OUT_183] = [__v_4]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_183(inp: [G; IN_183], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_183] = [__v_1]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = __v_0 + __v_1; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __v_3 * __v_3; let __ret: [G; OUT_183] = [__v_4]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_184: usize = 3; const IN_184: usize = 3; const OUT_184: usize = 2; -fn aiur_fn_184(inp: [G; IN_184], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; 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_184] = [__v_7, __v_8]; record.function_queries[184].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_184(inp: [G; IN_184], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; 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_184] = [__v_7, __v_8]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_185: usize = 1; const IN_185: usize = 1; const OUT_185: usize = 1; -fn aiur_fn_185(inp: [G; IN_185], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; 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_185] = { let __args: [G; IN_185] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); let __ret: [G; OUT_185] = [__v_5]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_185(inp: [G; IN_185], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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_185] = { let __args: [G; IN_185] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_1 * __v_4; let __ret: [G; OUT_185] = [__v_5]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_186: usize = 3; const IN_186: usize = 3; const OUT_186: usize = 8; -fn aiur_fn_186(inp: [G; IN_186], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; 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_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = aiur::execute::g_inverse_value(__v_9); let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_11 - __v_5); let __v_13: G = (__v_9 * __v_12); if (__v_13 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_14: G = (__v_10 * __v_12); if (__v_14 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_0 - __v_5); let __v_16: G = (__v_1 - __v_6); let __v_17: G = (__v_15 * __v_15); let __v_18: G = G::from_u64(7); let __v_19: G = (__v_16 * __v_16); let __v_20: G = (__v_18 * __v_19); let __v_21: G = (__v_17 - __v_20); let __v_22: G = aiur::execute::g_inverse_value(__v_21); let __v_23: G = (__v_21 * __v_22); let __v_24: G = (__v_23 - __v_5); let __v_25: G = (__v_21 * __v_24); if (__v_25 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_26: G = (__v_22 * __v_24); if (__v_26 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_27: G = (__v_15 * __v_22); let __v_28: G = (__v_6 - __v_16); let __v_29: G = (__v_28 * __v_22); let __v_30: G = (__v_7 * __v_27); let __v_31: G = (__v_8 * __v_29); let __v_32: G = (__v_18 * __v_31); let __v_33: G = (__v_30 + __v_32); let __v_34: G = (__v_7 * __v_29); let __v_35: G = (__v_8 * __v_27); let __v_36: G = (__v_34 + __v_35); let __v_37: G = (__v_0 - __v_10); let __v_38: G = (__v_37 * __v_37); let __v_39: G = (__v_38 - __v_20); let __v_40: G = aiur::execute::g_inverse_value(__v_39); let __v_41: G = (__v_39 * __v_40); let __v_42: G = (__v_41 - __v_5); let __v_43: G = (__v_39 * __v_42); if (__v_43 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_44: G = (__v_40 * __v_42); if (__v_44 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_45: G = (__v_37 * __v_40); let __v_46: G = (__v_28 * __v_40); let __v_47: G = (__v_7 * __v_45); let __v_48: G = (__v_8 * __v_46); let __v_49: G = (__v_18 * __v_48); let __v_50: G = (__v_47 + __v_49); let __v_51: G = (__v_7 * __v_46); let __v_52: G = (__v_8 * __v_45); let __v_53: G = (__v_51 + __v_52); let __v_54: G = (__v_7 * __v_7); let __v_55: G = (__v_8 * __v_8); let __v_56: G = (__v_18 * __v_55); let __v_57: G = (__v_54 - __v_56); let __v_58: G = aiur::execute::g_inverse_value(__v_57); let __v_59: G = (__v_57 * __v_58); let __v_60: G = (__v_59 - __v_5); let __v_61: G = (__v_57 * __v_60); if (__v_61 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_62: G = (__v_58 * __v_60); if (__v_62 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_63: G = (__v_7 * __v_58); let __v_64: G = (__v_6 - __v_8); let __v_65: G = (__v_64 * __v_58); let __ret: [G; OUT_186] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[186].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_186(inp: [G; IN_186], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; 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_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = aiur::execute::g_inverse_value(__v_9); let __v_11: G = __v_9 * __v_10; let __v_12: G = __v_11 - __v_5; let __v_13: G = __v_9 * __v_12; if (__v_13 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_14: G = __v_10 * __v_12; if (__v_14 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_15: G = __v_0 - __v_5; let __v_16: G = __v_1 - __v_6; let __v_17: G = __v_15 * __v_15; let __v_18: G = G::from_u64(7); let __v_19: G = __v_16 * __v_16; let __v_20: G = __v_18 * __v_19; let __v_21: G = __v_17 - __v_20; let __v_22: G = aiur::execute::g_inverse_value(__v_21); let __v_23: G = __v_21 * __v_22; let __v_24: G = __v_23 - __v_5; let __v_25: G = __v_21 * __v_24; if (__v_25 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_26: G = __v_22 * __v_24; if (__v_26 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_27: G = __v_15 * __v_22; let __v_28: G = __v_6 - __v_16; let __v_29: G = __v_28 * __v_22; let __v_30: G = __v_7 * __v_27; let __v_31: G = __v_8 * __v_29; let __v_32: G = __v_18 * __v_31; let __v_33: G = __v_30 + __v_32; let __v_34: G = __v_7 * __v_29; let __v_35: G = __v_8 * __v_27; let __v_36: G = __v_34 + __v_35; let __v_37: G = __v_0 - __v_10; let __v_38: G = __v_37 * __v_37; let __v_39: G = __v_38 - __v_20; let __v_40: G = aiur::execute::g_inverse_value(__v_39); let __v_41: G = __v_39 * __v_40; let __v_42: G = __v_41 - __v_5; let __v_43: G = __v_39 * __v_42; if (__v_43 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_44: G = __v_40 * __v_42; if (__v_44 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_45: G = __v_37 * __v_40; let __v_46: G = __v_28 * __v_40; let __v_47: G = __v_7 * __v_45; let __v_48: G = __v_8 * __v_46; let __v_49: G = __v_18 * __v_48; let __v_50: G = __v_47 + __v_49; let __v_51: G = __v_7 * __v_46; let __v_52: G = __v_8 * __v_45; let __v_53: G = __v_51 + __v_52; let __v_54: G = __v_7 * __v_7; let __v_55: G = __v_8 * __v_8; let __v_56: G = __v_18 * __v_55; let __v_57: G = __v_54 - __v_56; let __v_58: G = aiur::execute::g_inverse_value(__v_57); let __v_59: G = __v_57 * __v_58; let __v_60: G = __v_59 - __v_5; let __v_61: G = __v_57 * __v_60; if (__v_61 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_62: G = __v_58 * __v_60; if (__v_62 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_63: G = __v_7 * __v_58; let __v_64: G = __v_6 - __v_8; let __v_65: G = __v_64 * __v_58; let __ret: [G; OUT_186] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_187: usize = 6; const IN_187: usize = 6; const OUT_187: usize = 2; -fn aiur_fn_187(inp: [G; IN_187], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = (__v_0 * __v_2); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_1 * __v_3); let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_0 * __v_3); let __v_12: G = (__v_1 * __v_2); 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_187] = [__v_14, __v_15]; record.function_queries[187].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_187(inp: [G; IN_187], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = __v_0 * __v_2; let __v_7: G = G::from_u64(7); let __v_8: G = __v_1 * __v_3; let __v_9: G = __v_7 * __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_0 * __v_3; let __v_12: G = __v_1 * __v_2; 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_187] = [__v_14, __v_15]; record.function_queries[187].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_188: usize = 4; const IN_188: usize = 4; const OUT_188: usize = 2; -fn aiur_fn_188(inp: [G; IN_188], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 * __v_4); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_3 * __v_5); let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_2 * __v_5); let __v_12: G = (__v_3 * __v_4); 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_188] = [__v_14, __v_15]; record.function_queries[188].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_188(inp: [G; IN_188], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = __v_2 * __v_4; let __v_7: G = G::from_u64(7); let __v_8: G = __v_3 * __v_5; let __v_9: G = __v_7 * __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_2 * __v_5; let __v_12: G = __v_3 * __v_4; 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_188] = [__v_14, __v_15]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_189: usize = 1; const IN_189: usize = 1; const OUT_189: usize = 1; -fn aiur_fn_189(inp: [G; IN_189], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_6]; record.function_queries[189].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, (&__args[..]))?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { (*(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188])) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, (&__args[..]))?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { (*(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189])) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_13]; record.function_queries[189].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_189(inp: [G; IN_189], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_6]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, &__args[..])?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, &__args[..])?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_13]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_190: usize = 15; const IN_190: usize = 15; const OUT_190: usize = 2; -fn aiur_fn_190(inp: [G; IN_190], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(248, (&__args[..]))?) { [G::ZERO; OUT_248] } else { let (__hash, __hit) = record.function_queries[248].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[248].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { (*(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248])) }; __ret }, _ => { aiur_fn_248::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_190] = [__v_16, __v_19]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = (__v_16 + __v_17); let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_5, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_19, __v_20]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_190] = [__v_9, __v_10]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_190] = [__v_11, __v_12]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_190] = [__v_13, __v_14]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(7); let __v_25: G = (__v_20 * __v_22); let __v_26: G = (__v_24 * __v_25); let __v_27: G = (__v_23 + __v_26); 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_190] = [__v_27, __v_30]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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 = (__v_21 - __v_20); let __ret: [G; OUT_190] = [__v_22, __v_23]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } +fn aiur_fn_190(inp: [G; IN_190], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(248, &__args[..])?) { [G::ZERO; OUT_248] } else { let (__hash, __hit) = record.function_queries[248].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[248].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => { aiur_fn_248::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_190] = [__v_16, __v_19]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = __v_16 + __v_17; let __v_20: G = __v_16 + __v_19; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_5, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_19, __v_20]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_190] = [__v_9, __v_10]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_190] = [__v_11, __v_12]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_190] = [__v_13, __v_14]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(7); let __v_25: G = __v_20 * __v_22; let __v_26: G = __v_24 * __v_25; let __v_27: G = __v_23 + __v_26; 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_190] = [__v_27, __v_30]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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 = __v_21 - __v_20; let __ret: [G; OUT_190] = [__v_22, __v_23]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } const INPUT_SIZE_191: usize = 19; const IN_191: usize = 19; const OUT_191: usize = 2; -fn aiur_fn_191(inp: [G; IN_191], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_191] = [__v_0, __v_1]; record.function_queries[191].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__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 ((!unconstrained) && record.defer_call(191, (&__args[..]))?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { (*(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191])) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_26, __v_27]; record.function_queries[191].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } +fn aiur_fn_191(inp: [G; IN_191], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_191] = [__v_0, __v_1]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__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 ((!unconstrained) && record.defer_call(191, &__args[..])?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_26, __v_27]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } const INPUT_SIZE_192: usize = 8; const IN_192: usize = 8; const OUT_192: usize = 4; -fn aiur_fn_192(inp: [G; IN_192], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 = (__v_0 * __v_4); let __v_9: G = G::from_u64(7); let __v_10: G = (__v_1 * __v_5); let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_8 + __v_11); let __v_13: G = (__v_0 * __v_5); let __v_14: G = (__v_1 * __v_4); let __v_15: G = (__v_13 + __v_14); let __v_16: G = G::from_u64(0); let __v_17: G = (__v_2 * __v_6); let __v_18: G = (__v_3 * __v_7); let __v_19: G = (__v_9 * __v_18); let __v_20: G = (__v_17 + __v_19); let __v_21: G = (__v_2 * __v_7); let __v_22: G = (__v_3 * __v_6); let __v_23: G = (__v_21 + __v_22); let __v_24: G = (__v_9 * __v_20); let __v_25: G = (__v_16 * __v_23); let __v_26: G = (__v_9 * __v_25); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_9 * __v_23); let __v_29: G = (__v_16 * __v_20); let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_12 + __v_27); let __v_32: G = (__v_15 + __v_30); let __v_33: G = (__v_0 * __v_6); let __v_34: G = (__v_1 * __v_7); let __v_35: G = (__v_9 * __v_34); let __v_36: G = (__v_33 + __v_35); let __v_37: G = (__v_0 * __v_7); let __v_38: G = (__v_1 * __v_6); let __v_39: G = (__v_37 + __v_38); let __v_40: G = (__v_2 * __v_4); let __v_41: G = (__v_3 * __v_5); let __v_42: G = (__v_9 * __v_41); let __v_43: G = (__v_40 + __v_42); let __v_44: G = (__v_2 * __v_5); let __v_45: G = (__v_3 * __v_4); let __v_46: G = (__v_44 + __v_45); let __v_47: G = (__v_36 + __v_43); let __v_48: G = (__v_39 + __v_46); let __ret: [G; OUT_192] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_192(inp: [G; IN_192], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 = __v_0 * __v_4; let __v_9: G = G::from_u64(7); let __v_10: G = __v_1 * __v_5; let __v_11: G = __v_9 * __v_10; let __v_12: G = __v_8 + __v_11; let __v_13: G = __v_0 * __v_5; let __v_14: G = __v_1 * __v_4; let __v_15: G = __v_13 + __v_14; let __v_16: G = G::from_u64(0); let __v_17: G = __v_2 * __v_6; let __v_18: G = __v_3 * __v_7; let __v_19: G = __v_9 * __v_18; let __v_20: G = __v_17 + __v_19; let __v_21: G = __v_2 * __v_7; let __v_22: G = __v_3 * __v_6; let __v_23: G = __v_21 + __v_22; let __v_24: G = __v_9 * __v_20; let __v_25: G = __v_16 * __v_23; let __v_26: G = __v_9 * __v_25; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_9 * __v_23; let __v_29: G = __v_16 * __v_20; let __v_30: G = __v_28 + __v_29; let __v_31: G = __v_12 + __v_27; let __v_32: G = __v_15 + __v_30; let __v_33: G = __v_0 * __v_6; let __v_34: G = __v_1 * __v_7; let __v_35: G = __v_9 * __v_34; let __v_36: G = __v_33 + __v_35; let __v_37: G = __v_0 * __v_7; let __v_38: G = __v_1 * __v_6; let __v_39: G = __v_37 + __v_38; let __v_40: G = __v_2 * __v_4; let __v_41: G = __v_3 * __v_5; let __v_42: G = __v_9 * __v_41; let __v_43: G = __v_40 + __v_42; let __v_44: G = __v_2 * __v_5; let __v_45: G = __v_3 * __v_4; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_36 + __v_43; let __v_48: G = __v_39 + __v_46; let __ret: [G; OUT_192] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_193: usize = 19; const IN_193: usize = 19; const OUT_193: usize = 4; -fn aiur_fn_193(inp: [G; IN_193], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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 ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; 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_192] = { let __args: [G; IN_192] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; 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_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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_193] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } +fn aiur_fn_193(inp: [G; IN_193], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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 ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; 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_192] = { let __args: [G; IN_192] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; 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_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; 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_193] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } const INPUT_SIZE_194: usize = 44; const IN_194: usize = 44; const OUT_194: usize = 2; -fn aiur_fn_194(inp: [G; IN_194], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_194] = [__v_0, __v_1]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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 ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; 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 = (__v_48 + __v_22); 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_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = (__v_56 * __v_10); let __v_63: G = G::from_u64(7); let __v_64: G = (__v_57 * __v_11); let __v_65: G = (__v_63 * __v_64); let __v_66: G = (__v_62 + __v_65); let __v_67: G = (__v_56 * __v_11); let __v_68: G = (__v_57 * __v_10); let __v_69: G = (__v_67 + __v_68); let __v_70: G = (__v_58 + __v_66); let __v_71: G = (__v_59 + __v_69); let __v_72: G = (__v_56 * __v_12); let __v_73: G = (__v_57 * __v_13); let __v_74: G = (__v_63 * __v_73); let __v_75: G = (__v_72 + __v_74); let __v_76: G = (__v_56 * __v_13); let __v_77: G = (__v_57 * __v_12); let __v_78: G = (__v_76 + __v_77); let __v_79: G = (__v_60 + __v_75); let __v_80: G = (__v_61 + __v_78); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = G::from_u64(1); let __v_86: G = (__v_85 - __v_6); let __v_87: G = (__v_5 + __v_86); match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = (__v_7 + __v_7); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_88]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = __r_arr[1]; let __v_91: G = G::from_u64(1); let __v_92: G = (__v_7 + __v_91); let __v_93: G = (__v_7 + __v_92); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = (__v_97 + __v_18); let __v_100: G = (__v_98 + __v_19); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_91]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = (__v_101 + __v_20); let __v_104: G = (__v_102 + __v_21); let __v_105: G = (__v_99 - __v_89); let __v_106: G = (__v_100 - __v_90); let __v_107: G = (__v_103 - __v_94); let __v_108: G = (__v_104 - __v_95); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; let __v_111: G = __r_arr[2]; let __v_112: G = __r_arr[3]; let __v_113: G = (__v_109 - __v_70); let __v_114: G = (__v_110 - __v_71); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; let __v_117: G = (__v_111 - __v_79); let __v_118: G = (__v_112 - __v_80); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_119, __v_120]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_88: G = G::from_u64(1); let __v_89: G = (__v_8 - __v_88); match __v_89.as_canonical_u64() { 0u64 => { let __v_90: G = (__v_7 + __v_7); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = G::from_u64(1); let __v_94: G = (__v_7 + __v_93); let __v_95: G = (__v_7 + __v_94); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = G::from_u64(2); let __v_99: G = (__v_7 + __v_98); let __v_100: G = (__v_7 + __v_99); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = G::from_u64(3); let __v_104: G = (__v_7 + __v_103); let __v_105: G = (__v_7 + __v_104); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = (__v_101 - __v_91); let __v_109: G = (__v_102 - __v_92); let __v_110: G = (__v_106 - __v_96); let __v_111: G = (__v_107 - __v_97); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = __r_arr[2]; let __v_115: G = __r_arr[3]; let __v_116: G = (__v_112 - __v_70); let __v_117: G = (__v_113 - __v_71); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_116, __v_117]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = (__v_114 - __v_79); let __v_121: G = (__v_115 - __v_80); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_118, __v_119, __v_2, __v_3, __v_120, __v_121]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = (__v_5 + __v_93); let __v_125: G = G::from_u64(0); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_122, __v_123, __v_2, __v_3, __v_47, __v_124, __v_6, __v_94, __v_9, __v_9, __v_93, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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 ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_126: G = __r_arr[0]; let __v_127: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_126, __v_127]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_90: G = G::from_u64(1); let __v_91: G = (__v_5 + __v_90); let __v_92: G = (__v_8 - __v_90); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_91, __v_6, __v_7, __v_92, __v_9, __v_81, __v_82, __v_83, __v_84, __v_70, __v_71, __v_79, __v_80, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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 ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_93, __v_94]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } +fn aiur_fn_194(inp: [G; IN_194], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_194] = [__v_0, __v_1]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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 ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; 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 = __v_48 + __v_22; 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_190] = { let __args: [G; IN_190] = [__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 ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __v_56 * __v_10; let __v_63: G = G::from_u64(7); let __v_64: G = __v_57 * __v_11; let __v_65: G = __v_63 * __v_64; let __v_66: G = __v_62 + __v_65; let __v_67: G = __v_56 * __v_11; let __v_68: G = __v_57 * __v_10; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_58 + __v_66; let __v_71: G = __v_59 + __v_69; let __v_72: G = __v_56 * __v_12; let __v_73: G = __v_57 * __v_13; let __v_74: G = __v_63 * __v_73; let __v_75: G = __v_72 + __v_74; let __v_76: G = __v_56 * __v_13; let __v_77: G = __v_57 * __v_12; let __v_78: G = __v_76 + __v_77; let __v_79: G = __v_60 + __v_75; let __v_80: G = __v_61 + __v_78; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = G::from_u64(1); let __v_86: G = __v_85 - __v_6; let __v_87: G = __v_5 + __v_86; match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = __v_7 + __v_7; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_88]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = __r_arr[1]; let __v_91: G = G::from_u64(1); let __v_92: G = __v_7 + __v_91; let __v_93: G = __v_7 + __v_92; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = __v_97 + __v_18; let __v_100: G = __v_98 + __v_19; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_91]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = __v_101 + __v_20; let __v_104: G = __v_102 + __v_21; let __v_105: G = __v_99 - __v_89; let __v_106: G = __v_100 - __v_90; let __v_107: G = __v_103 - __v_94; let __v_108: G = __v_104 - __v_95; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; let __v_111: G = __r_arr[2]; let __v_112: G = __r_arr[3]; let __v_113: G = __v_109 - __v_70; let __v_114: G = __v_110 - __v_71; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; let __v_117: G = __v_111 - __v_79; let __v_118: G = __v_112 - __v_80; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_119, __v_120]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_88: G = G::from_u64(1); let __v_89: G = __v_8 - __v_88; match __v_89.as_canonical_u64() { 0u64 => { let __v_90: G = __v_7 + __v_7; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = G::from_u64(1); let __v_94: G = __v_7 + __v_93; let __v_95: G = __v_7 + __v_94; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = G::from_u64(2); let __v_99: G = __v_7 + __v_98; let __v_100: G = __v_7 + __v_99; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = G::from_u64(3); let __v_104: G = __v_7 + __v_103; let __v_105: G = __v_7 + __v_104; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __v_101 - __v_91; let __v_109: G = __v_102 - __v_92; let __v_110: G = __v_106 - __v_96; let __v_111: G = __v_107 - __v_97; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = __r_arr[2]; let __v_115: G = __r_arr[3]; let __v_116: G = __v_112 - __v_70; let __v_117: G = __v_113 - __v_71; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_116, __v_117]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = __v_114 - __v_79; let __v_121: G = __v_115 - __v_80; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_118, __v_119, __v_2, __v_3, __v_120, __v_121]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __v_5 + __v_93; let __v_125: G = G::from_u64(0); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_122, __v_123, __v_2, __v_3, __v_47, __v_124, __v_6, __v_94, __v_9, __v_9, __v_93, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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 ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_126: G = __r_arr[0]; let __v_127: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_126, __v_127]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_90: G = G::from_u64(1); let __v_91: G = __v_5 + __v_90; let __v_92: G = __v_8 - __v_90; let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_91, __v_6, __v_7, __v_92, __v_9, __v_81, __v_82, __v_83, __v_84, __v_70, __v_71, __v_79, __v_80, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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 ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_93, __v_94]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } const INPUT_SIZE_195: usize = 28; const IN_195: usize = 28; const OUT_195: usize = 2; -fn aiur_fn_195(inp: [G; IN_195], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_28, __v_28, __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 ((!unconstrained) && record.defer_call(191, (&__args[..]))?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { (*(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191])) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = (__v_17 - __v_15); let __v_32: G = (__v_28 - __v_28); let __v_33: G = (__v_31 * __v_27); let __v_34: G = G::from_u64(7); let __v_35: G = (__v_32 * __v_28); let __v_36: G = (__v_34 * __v_35); let __v_37: G = (__v_33 + __v_36); let __v_38: G = (__v_31 * __v_28); let __v_39: G = (__v_32 * __v_27); let __v_40: G = (__v_38 + __v_39); let __v_41: G = (__v_21 * __v_37); let __v_42: G = (__v_22 * __v_40); let __v_43: G = (__v_34 * __v_42); let __v_44: G = (__v_41 + __v_43); let __v_45: G = (__v_21 * __v_40); let __v_46: G = (__v_22 * __v_37); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_18 - __v_16); let __v_49: G = (__v_48 * __v_27); let __v_50: G = (__v_49 + __v_36); let __v_51: G = (__v_48 * __v_28); let __v_52: G = (__v_51 + __v_39); let __v_53: G = (__v_21 * __v_50); let __v_54: G = (__v_22 * __v_52); let __v_55: G = (__v_34 * __v_54); let __v_56: G = (__v_53 + __v_55); let __v_57: G = (__v_21 * __v_52); let __v_58: G = (__v_22 * __v_50); let __v_59: G = (__v_57 + __v_58); let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_60: G = __loaded[0]; let __v_61: G = __loaded[1]; let __v_62: G = __loaded[2]; let __v_63: G = __loaded[3]; match __v_60.as_canonical_u64() { 1u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = (__v_65 - __v_67); let __v_70: G = (__v_66 - __v_68); let __v_71: G = (__v_69 + __v_44); let __v_72: G = (__v_70 + __v_47); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __v_79: G = __r_arr[1]; let __v_80: G = (__v_76 - __v_78); let __v_81: G = (__v_77 - __v_79); let __v_82: G = (__v_80 + __v_56); let __v_83: G = (__v_81 + __v_59); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_84, __v_85]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_29, __v_30, __v_25, __v_26, __v_2, __v_64, __v_65, __v_64, __v_3, __v_3, __v_66, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_44, __v_47, __v_56, __v_59, __v_11, __v_28, __v_12, __v_28, __v_13, __v_28, __v_14, __v_28, __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 ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_67, __v_68]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } +fn aiur_fn_195(inp: [G; IN_195], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_28, __v_28, __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 ((!unconstrained) && record.defer_call(191, &__args[..])?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __v_17 - __v_15; let __v_32: G = __v_28 - __v_28; let __v_33: G = __v_31 * __v_27; let __v_34: G = G::from_u64(7); let __v_35: G = __v_32 * __v_28; let __v_36: G = __v_34 * __v_35; let __v_37: G = __v_33 + __v_36; let __v_38: G = __v_31 * __v_28; let __v_39: G = __v_32 * __v_27; let __v_40: G = __v_38 + __v_39; let __v_41: G = __v_21 * __v_37; let __v_42: G = __v_22 * __v_40; let __v_43: G = __v_34 * __v_42; let __v_44: G = __v_41 + __v_43; let __v_45: G = __v_21 * __v_40; let __v_46: G = __v_22 * __v_37; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_18 - __v_16; let __v_49: G = __v_48 * __v_27; let __v_50: G = __v_49 + __v_36; let __v_51: G = __v_48 * __v_28; let __v_52: G = __v_51 + __v_39; let __v_53: G = __v_21 * __v_50; let __v_54: G = __v_22 * __v_52; let __v_55: G = __v_34 * __v_54; let __v_56: G = __v_53 + __v_55; let __v_57: G = __v_21 * __v_52; let __v_58: G = __v_22 * __v_50; let __v_59: G = __v_57 + __v_58; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_60: G = __loaded[0]; let __v_61: G = __loaded[1]; let __v_62: G = __loaded[2]; let __v_63: G = __loaded[3]; match __v_60.as_canonical_u64() { 1u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = __v_65 - __v_67; let __v_70: G = __v_66 - __v_68; let __v_71: G = __v_69 + __v_44; let __v_72: G = __v_70 + __v_47; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __v_79: G = __r_arr[1]; let __v_80: G = __v_76 - __v_78; let __v_81: G = __v_77 - __v_79; let __v_82: G = __v_80 + __v_56; let __v_83: G = __v_81 + __v_59; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_84, __v_85]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_29, __v_30, __v_25, __v_26, __v_2, __v_64, __v_65, __v_64, __v_3, __v_3, __v_66, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_44, __v_47, __v_56, __v_59, __v_11, __v_28, __v_12, __v_28, __v_13, __v_28, __v_14, __v_28, __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 ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_67, __v_68]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } const INPUT_SIZE_196: usize = 8; const IN_196: usize = 8; const OUT_196: usize = 1; -fn aiur_fn_196(inp: [G; IN_196], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_5, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_4, __v_8, __v_13]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_3, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_2, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_1, __v_8, __v_16]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_0, __v_8, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_196] = [__v_18]; record.function_queries[196].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_196(inp: [G; IN_196], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_5, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_4, __v_8, __v_13]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_3, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_2, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_1, __v_8, __v_16]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_0, __v_8, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_196] = [__v_18]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_197: usize = 5; const IN_197: usize = 5; const OUT_197: usize = 2; -fn aiur_fn_197(inp: [G; IN_197], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_197] = [__v_9, __v_9]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = (__v_3 * __v_6); let __v_10: G = G::from_u64(7); let __v_11: G = (__v_4 * __v_7); let __v_12: G = (__v_10 * __v_11); let __v_13: G = (__v_9 + __v_12); let __v_14: G = (__v_3 * __v_7); let __v_15: G = (__v_4 * __v_6); let __v_16: G = (__v_14 + __v_15); let __v_17: G = (__v_3 * __v_1); let __v_18: G = (__v_4 * __v_2); let __v_19: G = (__v_10 * __v_18); let __v_20: G = (__v_17 + __v_19); let __v_21: G = (__v_3 * __v_2); let __v_22: G = (__v_4 * __v_1); let __v_23: G = (__v_21 + __v_22); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_1, __v_2, __v_20, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, (&__args[..]))?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { (*(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197])) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = (__v_13 + __v_24); let __v_27: G = (__v_16 + __v_25); let __ret: [G; OUT_197] = [__v_26, __v_27]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +fn aiur_fn_197(inp: [G; IN_197], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_197] = [__v_9, __v_9]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = __v_3 * __v_6; let __v_10: G = G::from_u64(7); let __v_11: G = __v_4 * __v_7; let __v_12: G = __v_10 * __v_11; let __v_13: G = __v_9 + __v_12; let __v_14: G = __v_3 * __v_7; let __v_15: G = __v_4 * __v_6; let __v_16: G = __v_14 + __v_15; let __v_17: G = __v_3 * __v_1; let __v_18: G = __v_4 * __v_2; let __v_19: G = __v_10 * __v_18; let __v_20: G = __v_17 + __v_19; let __v_21: G = __v_3 * __v_2; let __v_22: G = __v_4 * __v_1; let __v_23: G = __v_21 + __v_22; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_1, __v_2, __v_20, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, &__args[..])?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __v_13 + __v_24; let __v_27: G = __v_16 + __v_25; let __ret: [G; OUT_197] = [__v_26, __v_27]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } const INPUT_SIZE_198: usize = 1; const IN_198: usize = 1; const OUT_198: usize = 1; -fn aiur_fn_198(inp: [G; IN_198], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_198(inp: [G; IN_198], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_199: usize = 4; const IN_199: usize = 4; const OUT_199: usize = 2; -fn aiur_fn_199(inp: [G; IN_199], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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 = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { match __v_0.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_6, __v_8]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_199(inp: [G; IN_199], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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 = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_0.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_6, __v_8]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_200: usize = 20; const IN_200: usize = 20; const OUT_200: usize = 1; -fn aiur_fn_200(inp: [G; IN_200], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; match __v_20.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_31]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(32); let __v_33: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_31), (&__v_32)) } else { aiur::execute::bytes2_less_than_value(__v_31, __v_32, record) }; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(198, (&__args[..]))?) { [G::ZERO; OUT_198] } else { let (__hash, __hit) = record.function_queries[198].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[198].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { (*(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198])) }; __ret }, _ => { aiur_fn_198::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_45.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; break '__mc_0 [__v_49, __v_51]; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }; let __v_47: G = __mc_out___mc_0[0]; let __v_48: G = __mc_out___mc_0[1]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = (__v_49 - __v_27); let __v_51: G = G::from_bool((__v_50 == G::ZERO)); let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = (__v_53 - __v_27); let __v_55: G = G::from_bool((__v_54 == G::ZERO)); if (__v_55 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_56 - __v_29); let __v_58: G = G::from_bool((__v_57 == G::ZERO)); if (__v_58 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_59 - __v_29); let __v_61: G = G::from_bool((__v_60 == G::ZERO)); if (__v_61 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = (__v_62 - __v_28); let __v_64: G = G::from_bool((__v_63 == G::ZERO)); if (__v_64 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = (__v_65 - __v_28); let __v_67: G = G::from_bool((__v_66 == G::ZERO)); if (__v_67 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(0); let __v_71: G = (__v_68 - __v_52); let __v_72: G = (__v_69 - __v_70); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = aiur::execute::g_inverse_value(__v_73); let __v_75: G = (__v_73 * __v_74); let __v_76: G = (__v_75 - __v_52); let __v_77: G = (__v_73 * __v_76); if (__v_77 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_78: G = (__v_74 * __v_76); if (__v_78 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_79: G = (__v_18 - __v_52); let __v_80: G = (__v_19 - __v_70); let __v_81: G = (__v_79 * __v_79); let __v_82: G = G::from_u64(7); let __v_83: G = (__v_80 * __v_80); let __v_84: G = (__v_82 * __v_83); let __v_85: G = (__v_81 - __v_84); let __v_86: G = aiur::execute::g_inverse_value(__v_85); let __v_87: G = (__v_85 * __v_86); let __v_88: G = (__v_87 - __v_52); let __v_89: G = (__v_85 * __v_88); if (__v_89 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_90: G = (__v_86 * __v_88); if (__v_90 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_91: G = (__v_79 * __v_86); let __v_92: G = (__v_70 - __v_80); let __v_93: G = (__v_92 * __v_86); let __v_94: G = (__v_71 * __v_91); let __v_95: G = (__v_72 * __v_93); let __v_96: G = (__v_82 * __v_95); let __v_97: G = (__v_94 + __v_96); let __v_98: G = (__v_71 * __v_93); let __v_99: G = (__v_72 * __v_91); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_18 - __v_74); let __v_102: G = (__v_101 * __v_101); let __v_103: G = (__v_102 - __v_84); let __v_104: G = aiur::execute::g_inverse_value(__v_103); let __v_105: G = (__v_103 * __v_104); let __v_106: G = (__v_105 - __v_52); let __v_107: G = (__v_103 * __v_106); if (__v_107 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_108: G = (__v_104 * __v_106); if (__v_108 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_109: G = (__v_101 * __v_104); let __v_110: G = (__v_92 * __v_104); let __v_111: G = (__v_71 * __v_109); let __v_112: G = (__v_72 * __v_110); let __v_113: G = (__v_82 * __v_112); let __v_114: G = (__v_111 + __v_113); let __v_115: G = (__v_71 * __v_110); let __v_116: G = (__v_72 * __v_109); let __v_117: G = (__v_115 + __v_116); let __v_118: G = (__v_71 * __v_71); let __v_119: G = (__v_72 * __v_72); let __v_120: G = (__v_82 * __v_119); let __v_121: G = (__v_118 - __v_120); let __v_122: G = aiur::execute::g_inverse_value(__v_121); let __v_123: G = (__v_121 * __v_122); let __v_124: G = (__v_123 - __v_52); let __v_125: G = (__v_121 * __v_124); if (__v_125 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_122 * __v_124); if (__v_126 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_127: G = (__v_71 * __v_122); let __v_128: G = (__v_70 - __v_72); let __v_129: G = (__v_128 * __v_122); let __v_130: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_131: G = { let __values: [G; 4] = [__v_70, __v_37, __v_70, __v_130]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_132: G = { let __values: [G; 4] = [__v_70, __v_36, __v_70, __v_131]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_133: G = { let __values: [G; 4] = [__v_70, __v_11, __v_70, __v_132]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_134: G = { let __values: [G; 4] = [__v_70, __v_10, __v_70, __v_133]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_135: G = { let __values: [G; 4] = [__v_70, __v_15, __v_70, __v_134]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_136: G = { let __values: [G; 4] = [__v_70, __v_14, __v_70, __v_135]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_137: G = { let __values: [G; 4] = [__v_70, __v_13, __v_70, __v_136]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_138: G = { let __values: [G; 4] = [__v_70, __v_12, __v_70, __v_137]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_140: G = __r_arr[0]; let __v_141: G = (__v_139 * __v_140); let __v_142: G = aiur::execute::g_inverse_value(__v_141); let __v_143: G = (__v_141 * __v_142); let __v_144: G = (__v_143 - __v_52); let __v_145: G = (__v_141 * __v_144); if (__v_145 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_146: G = (__v_142 * __v_144); if (__v_146 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_70, __v_70, __v_16, __v_17, __v_23, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, (&__args[..]))?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { (*(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191])) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; let __v_149: G = (__v_36 - __v_10); let __v_150: G = (__v_70 - __v_70); let __v_151: G = (__v_149 * __v_142); let __v_152: G = (__v_150 * __v_70); let __v_153: G = (__v_82 * __v_152); let __v_154: G = (__v_151 + __v_153); let __v_155: G = (__v_149 * __v_70); let __v_156: G = (__v_150 * __v_142); let __v_157: G = (__v_155 + __v_156); let __v_158: G = (__v_114 * __v_154); let __v_159: G = (__v_117 * __v_157); let __v_160: G = (__v_82 * __v_159); let __v_161: G = (__v_158 + __v_160); let __v_162: G = (__v_114 * __v_157); let __v_163: G = (__v_117 * __v_154); let __v_164: G = (__v_162 + __v_163); let __v_165: G = (__v_37 - __v_11); let __v_166: G = (__v_165 * __v_142); let __v_167: G = (__v_166 + __v_153); let __v_168: G = (__v_165 * __v_70); let __v_169: G = (__v_168 + __v_156); let __v_170: G = (__v_114 * __v_167); let __v_171: G = (__v_117 * __v_169); let __v_172: G = (__v_82 * __v_171); let __v_173: G = (__v_170 + __v_172); let __v_174: G = (__v_114 * __v_169); let __v_175: G = (__v_117 * __v_167); let __v_176: G = (__v_174 + __v_175); let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_177: G = __loaded[0]; let __v_178: G = __loaded[1]; let __v_179: G = __loaded[2]; let __v_180: G = __loaded[3]; let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_177.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; let __v_186: G = (__v_182 - __v_184); let __v_187: G = (__v_183 - __v_185); let __v_188: G = (__v_186 + __v_161); let __v_189: G = (__v_187 + __v_164); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_190: G = __r_arr[0]; let __v_191: G = __r_arr[1]; let __v_192: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = (__v_193 - __v_195); let __v_198: G = (__v_194 - __v_196); let __v_199: G = (__v_197 + __v_173); let __v_200: G = (__v_198 + __v_176); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; break '__mc_1 [__v_201, __v_202]; }, 0u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_147, __v_148, __v_16, __v_17, __v_25, __v_181, __v_182, __v_181, __v_26, __v_26, __v_183, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_161, __v_164, __v_173, __v_176, __v_12, __v_70, __v_13, __v_70, __v_14, __v_70, __v_15, __v_70, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; break '__mc_1 [__v_184, __v_185]; }, _ => { return Err(ExecError::MatchNoCase(__v_177.as_canonical_u64())); }, } }; let __v_181: G = __mc_out___mc_1[0]; let __v_182: G = __mc_out___mc_1[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_183: G = __r_arr[0]; let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_183, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_185]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, (&__args[..]))?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { (*(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189])) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_186]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = (__v_187 - __v_35); let __v_189: G = G::from_bool((__v_188 == G::ZERO)); let __v_190: G = G::from_u64(1); if (__v_189 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_186, __v_191, __v_192, __v_190, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, (&__args[..]))?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { (*(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197])) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __v_195: G = (__v_181 * __v_127); let __v_196: G = G::from_u64(7); let __v_197: G = (__v_182 * __v_129); let __v_198: G = (__v_196 * __v_197); let __v_199: G = (__v_195 + __v_198); let __v_200: G = (__v_181 * __v_129); let __v_201: G = (__v_182 * __v_127); let __v_202: G = (__v_200 + __v_201); let __v_203: G = (__v_199 - __v_193); let __v_204: G = G::from_bool((__v_203 == G::ZERO)); let __v_205: G = (__v_202 - __v_194); let __v_206: G = G::from_bool((__v_205 == G::ZERO)); let __v_207: G = (__v_204 * __v_206); if (__v_207 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __v_208: G = (__v_9 + __v_190); let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_30, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_208, __v_36, __v_37, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, (&__args[..]))?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { (*(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200])) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_209: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_209]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } +fn aiur_fn_200(inp: [G; IN_200], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; match __v_20.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_31]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(32); let __v_33: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_31, &__v_32) } else { aiur::execute::bytes2_less_than_value(__v_31, __v_32, record) }; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(198, &__args[..])?) { [G::ZERO; OUT_198] } else { let (__hash, __hit) = record.function_queries[198].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[198].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => { aiur_fn_198::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_45.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; break '__mc_0 [__v_49, __v_51]; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }; let __v_47: G = __mc_out___mc_0[0]; let __v_48: G = __mc_out___mc_0[1]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __v_49 - __v_27; let __v_51: G = G::from_bool(__v_50 == G::ZERO); let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __v_53 - __v_27; let __v_55: G = G::from_bool(__v_54 == G::ZERO); if (__v_55 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __v_56 - __v_29; let __v_58: G = G::from_bool(__v_57 == G::ZERO); if (__v_58 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __v_59 - __v_29; let __v_61: G = G::from_bool(__v_60 == G::ZERO); if (__v_61 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = __v_62 - __v_28; let __v_64: G = G::from_bool(__v_63 == G::ZERO); if (__v_64 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __v_65 - __v_28; let __v_67: G = G::from_bool(__v_66 == G::ZERO); if (__v_67 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(0); let __v_71: G = __v_68 - __v_52; let __v_72: G = __v_69 - __v_70; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = aiur::execute::g_inverse_value(__v_73); let __v_75: G = __v_73 * __v_74; let __v_76: G = __v_75 - __v_52; let __v_77: G = __v_73 * __v_76; if (__v_77 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_78: G = __v_74 * __v_76; if (__v_78 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_79: G = __v_18 - __v_52; let __v_80: G = __v_19 - __v_70; let __v_81: G = __v_79 * __v_79; let __v_82: G = G::from_u64(7); let __v_83: G = __v_80 * __v_80; let __v_84: G = __v_82 * __v_83; let __v_85: G = __v_81 - __v_84; let __v_86: G = aiur::execute::g_inverse_value(__v_85); let __v_87: G = __v_85 * __v_86; let __v_88: G = __v_87 - __v_52; let __v_89: G = __v_85 * __v_88; if (__v_89 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_90: G = __v_86 * __v_88; if (__v_90 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_91: G = __v_79 * __v_86; let __v_92: G = __v_70 - __v_80; let __v_93: G = __v_92 * __v_86; let __v_94: G = __v_71 * __v_91; let __v_95: G = __v_72 * __v_93; let __v_96: G = __v_82 * __v_95; let __v_97: G = __v_94 + __v_96; let __v_98: G = __v_71 * __v_93; let __v_99: G = __v_72 * __v_91; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_18 - __v_74; let __v_102: G = __v_101 * __v_101; let __v_103: G = __v_102 - __v_84; let __v_104: G = aiur::execute::g_inverse_value(__v_103); let __v_105: G = __v_103 * __v_104; let __v_106: G = __v_105 - __v_52; let __v_107: G = __v_103 * __v_106; if (__v_107 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_108: G = __v_104 * __v_106; if (__v_108 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_109: G = __v_101 * __v_104; let __v_110: G = __v_92 * __v_104; let __v_111: G = __v_71 * __v_109; let __v_112: G = __v_72 * __v_110; let __v_113: G = __v_82 * __v_112; let __v_114: G = __v_111 + __v_113; let __v_115: G = __v_71 * __v_110; let __v_116: G = __v_72 * __v_109; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_71 * __v_71; let __v_119: G = __v_72 * __v_72; let __v_120: G = __v_82 * __v_119; let __v_121: G = __v_118 - __v_120; let __v_122: G = aiur::execute::g_inverse_value(__v_121); let __v_123: G = __v_121 * __v_122; let __v_124: G = __v_123 - __v_52; let __v_125: G = __v_121 * __v_124; if (__v_125 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_126: G = __v_122 * __v_124; if (__v_126 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_127: G = __v_71 * __v_122; let __v_128: G = __v_70 - __v_72; let __v_129: G = __v_128 * __v_122; let __v_130: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_131: G = { let __values: [G; 4] = [__v_70, __v_37, __v_70, __v_130]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_132: G = { let __values: [G; 4] = [__v_70, __v_36, __v_70, __v_131]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_133: G = { let __values: [G; 4] = [__v_70, __v_11, __v_70, __v_132]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_134: G = { let __values: [G; 4] = [__v_70, __v_10, __v_70, __v_133]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_135: G = { let __values: [G; 4] = [__v_70, __v_15, __v_70, __v_134]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_136: G = { let __values: [G; 4] = [__v_70, __v_14, __v_70, __v_135]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_137: G = { let __values: [G; 4] = [__v_70, __v_13, __v_70, __v_136]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_138: G = { let __values: [G; 4] = [__v_70, __v_12, __v_70, __v_137]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_140: G = __r_arr[0]; let __v_141: G = __v_139 * __v_140; let __v_142: G = aiur::execute::g_inverse_value(__v_141); let __v_143: G = __v_141 * __v_142; let __v_144: G = __v_143 - __v_52; let __v_145: G = __v_141 * __v_144; if (__v_145 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_146: G = __v_142 * __v_144; if (__v_146 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_70, __v_70, __v_16, __v_17, __v_23, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, &__args[..])?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; let __v_149: G = __v_36 - __v_10; let __v_150: G = __v_70 - __v_70; let __v_151: G = __v_149 * __v_142; let __v_152: G = __v_150 * __v_70; let __v_153: G = __v_82 * __v_152; let __v_154: G = __v_151 + __v_153; let __v_155: G = __v_149 * __v_70; let __v_156: G = __v_150 * __v_142; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_114 * __v_154; let __v_159: G = __v_117 * __v_157; let __v_160: G = __v_82 * __v_159; let __v_161: G = __v_158 + __v_160; let __v_162: G = __v_114 * __v_157; let __v_163: G = __v_117 * __v_154; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_37 - __v_11; let __v_166: G = __v_165 * __v_142; let __v_167: G = __v_166 + __v_153; let __v_168: G = __v_165 * __v_70; let __v_169: G = __v_168 + __v_156; let __v_170: G = __v_114 * __v_167; let __v_171: G = __v_117 * __v_169; let __v_172: G = __v_82 * __v_171; let __v_173: G = __v_170 + __v_172; let __v_174: G = __v_114 * __v_169; let __v_175: G = __v_117 * __v_167; let __v_176: G = __v_174 + __v_175; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_177: G = __loaded[0]; let __v_178: G = __loaded[1]; let __v_179: G = __loaded[2]; let __v_180: G = __loaded[3]; let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_177.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; let __v_186: G = __v_182 - __v_184; let __v_187: G = __v_183 - __v_185; let __v_188: G = __v_186 + __v_161; let __v_189: G = __v_187 + __v_164; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_190: G = __r_arr[0]; let __v_191: G = __r_arr[1]; let __v_192: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = __v_193 - __v_195; let __v_198: G = __v_194 - __v_196; let __v_199: G = __v_197 + __v_173; let __v_200: G = __v_198 + __v_176; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; break '__mc_1 [__v_201, __v_202]; }, 0u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_147, __v_148, __v_16, __v_17, __v_25, __v_181, __v_182, __v_181, __v_26, __v_26, __v_183, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_161, __v_164, __v_173, __v_176, __v_12, __v_70, __v_13, __v_70, __v_14, __v_70, __v_15, __v_70, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; break '__mc_1 [__v_184, __v_185]; }, _ => { return Err(ExecError::MatchNoCase(__v_177.as_canonical_u64())); }, } }; let __v_181: G = __mc_out___mc_1[0]; let __v_182: G = __mc_out___mc_1[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_183: G = __r_arr[0]; let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_183, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_185]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, &__args[..])?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_186]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __v_187 - __v_35; let __v_189: G = G::from_bool(__v_188 == G::ZERO); let __v_190: G = G::from_u64(1); if (__v_189 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_186, __v_191, __v_192, __v_190, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, &__args[..])?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __v_195: G = __v_181 * __v_127; let __v_196: G = G::from_u64(7); let __v_197: G = __v_182 * __v_129; let __v_198: G = __v_196 * __v_197; let __v_199: G = __v_195 + __v_198; let __v_200: G = __v_181 * __v_129; let __v_201: G = __v_182 * __v_127; let __v_202: G = __v_200 + __v_201; let __v_203: G = __v_199 - __v_193; let __v_204: G = G::from_bool(__v_203 == G::ZERO); let __v_205: G = __v_202 - __v_194; let __v_206: G = G::from_bool(__v_205 == G::ZERO); let __v_207: G = __v_204 * __v_206; if (__v_207 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __v_208: G = __v_9 + __v_190; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_30, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_208, __v_36, __v_37, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, &__args[..])?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_209: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_209]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } const INPUT_SIZE_201: usize = 3; const IN_201: usize = 3; const OUT_201: usize = 2; -fn aiur_fn_201(inp: [G; IN_201], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_201] = [__v_13, __v_13]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_5); let __v_15: G = G::from_u64(65536); let __v_16: G = (__v_15 * __v_6); let __v_17: G = G::from_u64(16777216); let __v_18: G = (__v_17 * __v_7); let __v_19: G = G::from_u64(4294967296); let __v_20: G = (__v_19 * __v_8); let __v_21: G = G::from_u64(1099511627776); let __v_22: G = (__v_21 * __v_9); let __v_23: G = G::from_u64(281474976710656); let __v_24: G = (__v_23 * __v_10); let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = (__v_25 * __v_11); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_22 + __v_27); let __v_29: G = (__v_20 + __v_28); let __v_30: G = (__v_18 + __v_29); let __v_31: G = (__v_16 + __v_30); 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_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, (&__args[..]))?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { (*(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201])) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = (__v_0 * __v_35); let __v_38: G = G::from_u64(7); let __v_39: G = (__v_1 * __v_36); let __v_40: G = (__v_38 * __v_39); let __v_41: G = (__v_37 + __v_40); let __v_42: G = (__v_0 * __v_36); let __v_43: G = (__v_1 * __v_35); 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_201] = [__v_45, __v_46]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_201(inp: [G; IN_201], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_201] = [__v_13, __v_13]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_13: G = G::from_u64(256); let __v_14: G = __v_13 * __v_5; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_6; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_7; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_8; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_9; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_10; let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = __v_25 * __v_11; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_22 + __v_27; let __v_29: G = __v_20 + __v_28; let __v_30: G = __v_18 + __v_29; let __v_31: G = __v_16 + __v_30; 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_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, &__args[..])?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __v_0 * __v_35; let __v_38: G = G::from_u64(7); let __v_39: G = __v_1 * __v_36; let __v_40: G = __v_38 * __v_39; let __v_41: G = __v_37 + __v_40; let __v_42: G = __v_0 * __v_36; let __v_43: G = __v_1 * __v_35; 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_201] = [__v_45, __v_46]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_202: usize = 7; const IN_202: usize = 7; const OUT_202: usize = 2; -fn aiur_fn_202(inp: [G; IN_202], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_202] = [__v_0, __v_1]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, (&__args[..]))?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { (*(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201])) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = (__v_3 + __v_10); let __v_13: G = (__v_4 + __v_11); let __v_14: G = (__v_12 * __v_12); let __v_15: G = G::from_u64(7); let __v_16: G = (__v_13 * __v_13); let __v_17: G = (__v_15 * __v_16); let __v_18: G = (__v_14 - __v_17); let __v_19: G = aiur::execute::g_inverse_value(__v_18); let __v_20: G = (__v_18 * __v_19); let __v_21: G = G::from_u64(1); let __v_22: G = (__v_20 - __v_21); let __v_23: G = (__v_18 * __v_22); 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 __v_25: G = (__v_19 * __v_22); if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_26: G = (__v_12 * __v_19); let __v_27: G = (__v_24 - __v_13); let __v_28: G = (__v_27 * __v_19); let __v_29: G = (__v_0 + __v_26); let __v_30: G = (__v_1 + __v_28); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, (&__args[..]))?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { (*(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202])) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_202] = [__v_31, __v_32]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_202(inp: [G; IN_202], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_202] = [__v_0, __v_1]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, &__args[..])?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __v_3 + __v_10; let __v_13: G = __v_4 + __v_11; let __v_14: G = __v_12 * __v_12; let __v_15: G = G::from_u64(7); let __v_16: G = __v_13 * __v_13; let __v_17: G = __v_15 * __v_16; let __v_18: G = __v_14 - __v_17; let __v_19: G = aiur::execute::g_inverse_value(__v_18); let __v_20: G = __v_18 * __v_19; let __v_21: G = G::from_u64(1); let __v_22: G = __v_20 - __v_21; let __v_23: G = __v_18 * __v_22; 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 __v_25: G = __v_19 * __v_22; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_26: G = __v_12 * __v_19; let __v_27: G = __v_24 - __v_13; let __v_28: G = __v_27 * __v_19; let __v_29: G = __v_0 + __v_26; let __v_30: G = __v_1 + __v_28; let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, &__args[..])?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_202] = [__v_31, __v_32]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_203: usize = 1; const IN_203: usize = 1; const OUT_203: usize = 1; -fn aiur_fn_203(inp: [G; IN_203], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_203] = [__v_4]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); let __v_6: G = (__v_2 * __v_5); let __v_7: G = G::from_u64(0); 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_203] = { let __args: [G; IN_203] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, (&__args[..]))?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { (*(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203])) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_8]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_203(inp: [G; IN_203], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_203] = [__v_4]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_2 - __v_4; let __v_6: G = __v_2 * __v_5; let __v_7: G = G::from_u64(0); 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_203] = { let __args: [G; IN_203] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, &__args[..])?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_8]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_204: usize = 2; const IN_204: usize = 2; const OUT_204: usize = 1; -fn aiur_fn_204(inp: [G; IN_204], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 11] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_14]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_204] = [__v_16]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 11] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_18]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_204(inp: [G; IN_204], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 11] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_14]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_204] = [__v_16]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 11] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_18]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_205: usize = 2; const IN_205: usize = 2; const OUT_205: usize = 1; -fn aiur_fn_205(inp: [G; IN_205], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 => { match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_205] = [__v_9]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_11]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_205(inp: [G; IN_205], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 => { match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_205] = [__v_9]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_11]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_206: usize = 2; const IN_206: usize = 2; const OUT_206: usize = 1; -fn aiur_fn_206(inp: [G; IN_206], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_2: G = G::from_u8(__gb[0]); let __v_3: G = G::from_u8(__gb[1]); let __v_4: G = G::from_u8(__gb[2]); let __v_5: G = G::from_u8(__gb[3]); let __v_6: G = G::from_u8(__gb[4]); let __v_7: G = G::from_u8(__gb[5]); let __v_8: G = G::from_u8(__gb[6]); let __v_9: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_2; let __vj = __v_3; 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_4; let __vj = __v_5; 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_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_10: G = G::from_u64(256); let __v_11: G = (__v_10 * __v_3); let __v_12: G = G::from_u64(65536); let __v_13: G = (__v_12 * __v_4); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_5); let __v_16: G = G::from_u64(4294967296); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(1099511627776); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(281474976710656); let __v_21: G = (__v_20 * __v_8); let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = (__v_22 * __v_9); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_2 + __v_29); if (__v_30 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_31: G = G::from_u64(1020); let __v_32: G = (__v_9 - __v_31); let __v_33: G = (__v_8 + __v_32); let __v_34: G = (__v_7 + __v_33); let __v_35: G = (__v_6 + __v_34); let __v_36: G = G::from_bool((__v_35 == G::ZERO)); let __v_37: G = (__v_4 + __v_5); let __v_38: G = (__v_3 + __v_37); let __v_39: G = (__v_2 + __v_38); let __v_40: G = G::from_bool((__v_39 == G::ZERO)); let __v_41: G = G::from_u64(1); let __v_42: G = (__v_41 - __v_40); let __v_43: G = (__v_36 * __v_42); let __v_44: G = (__v_41 - __v_43); if (__v_44 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_45]; record.function_queries[206].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_206(inp: [G; IN_206], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_2: G = G::from_u8(__gb[0]); let __v_3: G = G::from_u8(__gb[1]); let __v_4: G = G::from_u8(__gb[2]); let __v_5: G = G::from_u8(__gb[3]); let __v_6: G = G::from_u8(__gb[4]); let __v_7: G = G::from_u8(__gb[5]); let __v_8: G = G::from_u8(__gb[6]); let __v_9: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_2; let __vj = __v_3; 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_4; let __vj = __v_5; 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_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_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_3; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_4; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_5; let __v_16: G = G::from_u64(4294967296); let __v_17: G = __v_16 * __v_6; let __v_18: G = G::from_u64(1099511627776); let __v_19: G = __v_18 * __v_7; let __v_20: G = G::from_u64(281474976710656); let __v_21: G = __v_20 * __v_8; let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = __v_22 * __v_9; let __v_24: G = __v_21 + __v_23; let __v_25: G = __v_19 + __v_24; let __v_26: G = __v_17 + __v_25; let __v_27: G = __v_15 + __v_26; let __v_28: G = __v_13 + __v_27; let __v_29: G = __v_11 + __v_28; let __v_30: G = __v_2 + __v_29; if (__v_30 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_31: G = G::from_u64(1020); let __v_32: G = __v_9 - __v_31; let __v_33: G = __v_8 + __v_32; let __v_34: G = __v_7 + __v_33; let __v_35: G = __v_6 + __v_34; let __v_36: G = G::from_bool(__v_35 == G::ZERO); let __v_37: G = __v_4 + __v_5; let __v_38: G = __v_3 + __v_37; let __v_39: G = __v_2 + __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = G::from_u64(1); let __v_42: G = __v_41 - __v_40; let __v_43: G = __v_36 * __v_42; let __v_44: G = __v_41 - __v_43; if (__v_44 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_45]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_207: usize = 2; const IN_207: usize = 2; const OUT_207: usize = 1; -fn aiur_fn_207(inp: [G; IN_207], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, (&__args[..]))?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { (*(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208])) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_4]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_207(inp: [G; IN_207], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, &__args[..])?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_4]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_208: usize = 2; const IN_208: usize = 2; const OUT_208: usize = 1; -fn aiur_fn_208(inp: [G; IN_208], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_208] = [__v_1]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, (&__args[..]))?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { (*(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208])) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_8]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_208(inp: [G; IN_208], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_208] = [__v_1]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, &__args[..])?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_8]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_209: usize = 5; const IN_209: usize = 5; const OUT_209: usize = 1; -fn aiur_fn_209(inp: [G; IN_209], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, (&__args[..]))?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { (*(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207])) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_10]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_209(inp: [G; IN_209], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, &__args[..])?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_10]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_210: usize = 2; const IN_210: usize = 2; const OUT_210: usize = 1; -fn aiur_fn_210(inp: [G; IN_210], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_210] = [__v_1]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, (&__args[..]))?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { (*(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210])) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3, __v_4, __v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_9]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_210(inp: [G; IN_210], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_210] = [__v_1]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, &__args[..])?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3, __v_4, __v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_9]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_211: usize = 2; const IN_211: usize = 2; const OUT_211: usize = 1; -fn aiur_fn_211(inp: [G; IN_211], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, (&__args[..]))?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { (*(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212])) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_4]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_211(inp: [G; IN_211], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, &__args[..])?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_4]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_212: usize = 2; const IN_212: usize = 2; const OUT_212: usize = 1; -fn aiur_fn_212(inp: [G; IN_212], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_212] = [__v_1]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_12, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, (&__args[..]))?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { (*(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212])) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_17]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_212(inp: [G; IN_212], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_212] = [__v_1]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_12, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, &__args[..])?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_17]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_213: usize = 4; const IN_213: usize = 4; const OUT_213: usize = 5; -fn aiur_fn_213(inp: [G; IN_213], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, (&__args[..]))?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { (*(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211])) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, (&__args[..]))?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { (*(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210])) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(109); let __v_14: G = G::from_u64(117); let __v_15: G = G::from_u64(108); let __v_16: G = G::from_u64(116); let __v_17: G = G::from_u64(105); let __v_18: G = G::from_u64(45); let __v_19: G = G::from_u64(115); let __v_20: G = G::from_u64(97); let __v_21: G = G::from_u64(114); let __v_22: G = G::from_u64(107); let __v_23: G = G::from_u64(47); let __v_24: G = G::from_u64(118); let __v_25: G = G::from_u64(48); let __v_26: G = { let __values: [G; 3] = [__v_12, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_12, __v_24, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_12, __v_23, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_29: G = { let __values: [G; 3] = [__v_12, __v_22, __v_28]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_30: G = { let __values: [G; 3] = [__v_12, __v_21, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_31: G = { let __values: [G; 3] = [__v_12, __v_20, __v_30]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_32: G = { let __values: [G; 3] = [__v_12, __v_16, __v_31]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_33: G = { let __values: [G; 3] = [__v_12, __v_19, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = { let __values: [G; 3] = [__v_12, __v_18, __v_33]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_35: G = { let __values: [G; 3] = [__v_12, __v_17, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_12, __v_16, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_12, __v_15, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_12, __v_14, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_12, __v_13, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_39, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __v_43: G = __r_arr[3]; let __v_44: G = __r_arr[4]; let __v_45: G = __r_arr[5]; let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; let __v_49: G = __r_arr[9]; let __v_50: G = __r_arr[10]; let __v_51: G = __r_arr[11]; let __v_52: G = __r_arr[12]; let __v_53: G = __r_arr[13]; let __v_54: G = __r_arr[14]; let __v_55: G = __r_arr[15]; let __v_56: G = __r_arr[16]; let __v_57: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_56, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_60, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __v_72: G = __r_arr[11]; let __v_73: G = __r_arr[12]; let __v_74: G = __r_arr[13]; let __v_75: G = __r_arr[14]; let __v_76: G = __r_arr[15]; let __v_77: G = __r_arr[16]; let __v_78: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_77, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = G::from_u64(256); let __v_83: G = (__v_82 * __v_41); let __v_84: G = G::from_u64(65536); let __v_85: G = (__v_84 * __v_42); let __v_86: G = G::from_u64(16777216); let __v_87: G = (__v_86 * __v_43); let __v_88: G = G::from_u64(4294967296); let __v_89: G = (__v_88 * __v_44); let __v_90: G = G::from_u64(1099511627776); let __v_91: G = (__v_90 * __v_45); let __v_92: G = G::from_u64(281474976710656); let __v_93: G = (__v_92 * __v_46); let __v_94: G = G::from_u64(72057594037927936); let __v_95: G = (__v_94 * __v_47); 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_40 + __v_101); let __v_103: G = (__v_82 * __v_49); let __v_104: G = (__v_84 * __v_50); let __v_105: G = (__v_86 * __v_51); let __v_106: G = (__v_88 * __v_52); let __v_107: G = (__v_90 * __v_53); let __v_108: G = (__v_92 * __v_54); let __v_109: G = (__v_94 * __v_55); let __v_110: G = (__v_108 + __v_109); let __v_111: G = (__v_107 + __v_110); let __v_112: G = (__v_106 + __v_111); let __v_113: G = (__v_105 + __v_112); let __v_114: G = (__v_104 + __v_113); let __v_115: G = (__v_103 + __v_114); let __v_116: G = (__v_48 + __v_115); let __v_117: G = (__v_82 * __v_62); let __v_118: G = (__v_84 * __v_63); let __v_119: G = (__v_86 * __v_64); let __v_120: G = (__v_88 * __v_65); let __v_121: G = (__v_90 * __v_66); let __v_122: G = (__v_92 * __v_67); let __v_123: G = (__v_94 * __v_68); let __v_124: G = (__v_122 + __v_123); let __v_125: G = (__v_121 + __v_124); let __v_126: G = (__v_120 + __v_125); let __v_127: G = (__v_119 + __v_126); let __v_128: G = (__v_118 + __v_127); let __v_129: G = (__v_117 + __v_128); let __v_130: G = (__v_61 + __v_129); let __v_131: G = (__v_82 * __v_70); let __v_132: G = (__v_84 * __v_71); let __v_133: G = (__v_86 * __v_72); let __v_134: G = (__v_88 * __v_73); let __v_135: G = (__v_90 * __v_74); let __v_136: G = (__v_92 * __v_75); let __v_137: G = (__v_94 * __v_76); let __v_138: G = (__v_136 + __v_137); let __v_139: G = (__v_135 + __v_138); let __v_140: G = (__v_134 + __v_139); let __v_141: G = (__v_133 + __v_140); let __v_142: G = (__v_132 + __v_141); let __v_143: G = (__v_131 + __v_142); let __v_144: G = (__v_69 + __v_143); let __ret: [G; OUT_213] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[213].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_213(inp: [G; IN_213], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, &__args[..])?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, &__args[..])?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(109); let __v_14: G = G::from_u64(117); let __v_15: G = G::from_u64(108); let __v_16: G = G::from_u64(116); let __v_17: G = G::from_u64(105); let __v_18: G = G::from_u64(45); let __v_19: G = G::from_u64(115); let __v_20: G = G::from_u64(97); let __v_21: G = G::from_u64(114); let __v_22: G = G::from_u64(107); let __v_23: G = G::from_u64(47); let __v_24: G = G::from_u64(118); let __v_25: G = G::from_u64(48); let __v_26: G = { let __values: [G; 3] = [__v_12, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_12, __v_24, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_12, __v_23, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_29: G = { let __values: [G; 3] = [__v_12, __v_22, __v_28]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_30: G = { let __values: [G; 3] = [__v_12, __v_21, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_31: G = { let __values: [G; 3] = [__v_12, __v_20, __v_30]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_32: G = { let __values: [G; 3] = [__v_12, __v_16, __v_31]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_33: G = { let __values: [G; 3] = [__v_12, __v_19, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = { let __values: [G; 3] = [__v_12, __v_18, __v_33]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_35: G = { let __values: [G; 3] = [__v_12, __v_17, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_12, __v_16, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_12, __v_15, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_12, __v_14, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_12, __v_13, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_39, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __v_43: G = __r_arr[3]; let __v_44: G = __r_arr[4]; let __v_45: G = __r_arr[5]; let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; let __v_49: G = __r_arr[9]; let __v_50: G = __r_arr[10]; let __v_51: G = __r_arr[11]; let __v_52: G = __r_arr[12]; let __v_53: G = __r_arr[13]; let __v_54: G = __r_arr[14]; let __v_55: G = __r_arr[15]; let __v_56: G = __r_arr[16]; let __v_57: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_56, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_60, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __v_72: G = __r_arr[11]; let __v_73: G = __r_arr[12]; let __v_74: G = __r_arr[13]; let __v_75: G = __r_arr[14]; let __v_76: G = __r_arr[15]; let __v_77: G = __r_arr[16]; let __v_78: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_77, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = G::from_u64(256); let __v_83: G = __v_82 * __v_41; let __v_84: G = G::from_u64(65536); let __v_85: G = __v_84 * __v_42; let __v_86: G = G::from_u64(16777216); let __v_87: G = __v_86 * __v_43; let __v_88: G = G::from_u64(4294967296); let __v_89: G = __v_88 * __v_44; let __v_90: G = G::from_u64(1099511627776); let __v_91: G = __v_90 * __v_45; let __v_92: G = G::from_u64(281474976710656); let __v_93: G = __v_92 * __v_46; let __v_94: G = G::from_u64(72057594037927936); let __v_95: G = __v_94 * __v_47; 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_40 + __v_101; let __v_103: G = __v_82 * __v_49; let __v_104: G = __v_84 * __v_50; let __v_105: G = __v_86 * __v_51; let __v_106: G = __v_88 * __v_52; let __v_107: G = __v_90 * __v_53; let __v_108: G = __v_92 * __v_54; let __v_109: G = __v_94 * __v_55; let __v_110: G = __v_108 + __v_109; let __v_111: G = __v_107 + __v_110; let __v_112: G = __v_106 + __v_111; let __v_113: G = __v_105 + __v_112; let __v_114: G = __v_104 + __v_113; let __v_115: G = __v_103 + __v_114; let __v_116: G = __v_48 + __v_115; let __v_117: G = __v_82 * __v_62; let __v_118: G = __v_84 * __v_63; let __v_119: G = __v_86 * __v_64; let __v_120: G = __v_88 * __v_65; let __v_121: G = __v_90 * __v_66; let __v_122: G = __v_92 * __v_67; let __v_123: G = __v_94 * __v_68; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_121 + __v_124; let __v_126: G = __v_120 + __v_125; let __v_127: G = __v_119 + __v_126; let __v_128: G = __v_118 + __v_127; let __v_129: G = __v_117 + __v_128; let __v_130: G = __v_61 + __v_129; let __v_131: G = __v_82 * __v_70; let __v_132: G = __v_84 * __v_71; let __v_133: G = __v_86 * __v_72; let __v_134: G = __v_88 * __v_73; let __v_135: G = __v_90 * __v_74; let __v_136: G = __v_92 * __v_75; let __v_137: G = __v_94 * __v_76; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_135 + __v_138; let __v_140: G = __v_134 + __v_139; let __v_141: G = __v_133 + __v_140; let __v_142: G = __v_132 + __v_141; let __v_143: G = __v_131 + __v_142; let __v_144: G = __v_69 + __v_143; let __ret: [G; OUT_213] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_214: usize = 5; const IN_214: usize = 5; const OUT_214: usize = 5; -fn aiur_fn_214(inp: [G; IN_214], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_5: G = G::from_u8(__gb[0]); let __v_6: G = G::from_u8(__gb[1]); let __v_7: G = G::from_u8(__gb[2]); let __v_8: G = G::from_u8(__gb[3]); let __v_9: G = G::from_u8(__gb[4]); let __v_10: G = G::from_u8(__gb[5]); let __v_11: G = G::from_u8(__gb[6]); let __v_12: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; 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_11; let __vj = __v_12; 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_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_6); let __v_15: G = G::from_u64(65536); let __v_16: G = (__v_15 * __v_7); let __v_17: G = G::from_u64(16777216); let __v_18: G = (__v_17 * __v_8); let __v_19: G = G::from_u64(4294967296); let __v_20: G = (__v_19 * __v_9); let __v_21: G = G::from_u64(1099511627776); let __v_22: G = (__v_21 * __v_10); let __v_23: G = G::from_u64(281474976710656); let __v_24: G = (__v_23 * __v_11); let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = (__v_25 * __v_12); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_22 + __v_27); let __v_29: G = (__v_20 + __v_28); let __v_30: G = (__v_18 + __v_29); let __v_31: G = (__v_16 + __v_30); let __v_32: G = (__v_14 + __v_31); let __v_33: G = (__v_5 + __v_32); if (__v_33 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_34: G = G::from_u64(1020); let __v_35: G = (__v_12 - __v_34); let __v_36: G = (__v_11 + __v_35); let __v_37: G = (__v_10 + __v_36); let __v_38: G = (__v_9 + __v_37); let __v_39: G = G::from_bool((__v_38 == G::ZERO)); let __v_40: G = (__v_7 + __v_8); let __v_41: G = (__v_6 + __v_40); let __v_42: G = (__v_5 + __v_41); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); let __v_44: G = G::from_u64(1); let __v_45: G = (__v_44 - __v_43); let __v_46: G = (__v_39 * __v_45); let __v_47: G = (__v_44 - __v_46); if (__v_47 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 3] = [__v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_4, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_49, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_52, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_71, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __v_83: G = __r_arr[11]; let __v_84: G = __r_arr[12]; let __v_85: G = __r_arr[13]; let __v_86: G = __r_arr[14]; let __v_87: G = __r_arr[15]; let __v_88: G = __r_arr[16]; let __v_89: G = __r_arr[17]; let __v_90: G = (__v_13 * __v_54); let __v_91: G = (__v_15 * __v_55); let __v_92: G = (__v_17 * __v_56); let __v_93: G = (__v_19 * __v_57); let __v_94: G = (__v_21 * __v_58); let __v_95: G = (__v_23 * __v_59); let __v_96: G = (__v_25 * __v_60); let __v_97: G = (__v_95 + __v_96); let __v_98: G = (__v_94 + __v_97); let __v_99: G = (__v_93 + __v_98); let __v_100: G = (__v_92 + __v_99); let __v_101: G = (__v_91 + __v_100); let __v_102: G = (__v_90 + __v_101); let __v_103: G = (__v_53 + __v_102); let __v_104: G = (__v_13 * __v_62); let __v_105: G = (__v_15 * __v_63); let __v_106: G = (__v_17 * __v_64); let __v_107: G = (__v_19 * __v_65); let __v_108: G = (__v_21 * __v_66); let __v_109: G = (__v_23 * __v_67); let __v_110: G = (__v_25 * __v_68); let __v_111: G = (__v_109 + __v_110); let __v_112: G = (__v_108 + __v_111); let __v_113: G = (__v_107 + __v_112); let __v_114: G = (__v_106 + __v_113); let __v_115: G = (__v_105 + __v_114); let __v_116: G = (__v_104 + __v_115); let __v_117: G = (__v_61 + __v_116); let __v_118: G = (__v_13 * __v_73); let __v_119: G = (__v_15 * __v_74); let __v_120: G = (__v_17 * __v_75); let __v_121: G = (__v_19 * __v_76); let __v_122: G = (__v_21 * __v_77); let __v_123: G = (__v_23 * __v_78); let __v_124: G = (__v_25 * __v_79); let __v_125: G = (__v_123 + __v_124); let __v_126: G = (__v_122 + __v_125); let __v_127: G = (__v_121 + __v_126); let __v_128: G = (__v_120 + __v_127); let __v_129: G = (__v_119 + __v_128); let __v_130: G = (__v_118 + __v_129); let __v_131: G = (__v_72 + __v_130); let __v_132: G = (__v_13 * __v_81); let __v_133: G = (__v_15 * __v_82); let __v_134: G = (__v_17 * __v_83); let __v_135: G = (__v_19 * __v_84); let __v_136: G = (__v_21 * __v_85); let __v_137: G = (__v_23 * __v_86); let __v_138: G = (__v_25 * __v_87); let __v_139: G = (__v_137 + __v_138); let __v_140: G = (__v_136 + __v_139); let __v_141: G = (__v_135 + __v_140); let __v_142: G = (__v_134 + __v_141); let __v_143: G = (__v_133 + __v_142); let __v_144: G = (__v_132 + __v_143); let __v_145: G = (__v_80 + __v_144); let __ret: [G; OUT_214] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_214(inp: [G; IN_214], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_5: G = G::from_u8(__gb[0]); let __v_6: G = G::from_u8(__gb[1]); let __v_7: G = G::from_u8(__gb[2]); let __v_8: G = G::from_u8(__gb[3]); let __v_9: G = G::from_u8(__gb[4]); let __v_10: G = G::from_u8(__gb[5]); let __v_11: G = G::from_u8(__gb[6]); let __v_12: G = G::from_u8(__gb[7]); 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); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; 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_11; let __vj = __v_12; 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_13: G = G::from_u64(256); let __v_14: G = __v_13 * __v_6; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_7; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_8; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_9; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_10; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_11; let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = __v_25 * __v_12; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_22 + __v_27; let __v_29: G = __v_20 + __v_28; let __v_30: G = __v_18 + __v_29; let __v_31: G = __v_16 + __v_30; let __v_32: G = __v_14 + __v_31; let __v_33: G = __v_5 + __v_32; if (__v_33 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_34: G = G::from_u64(1020); let __v_35: G = __v_12 - __v_34; let __v_36: G = __v_11 + __v_35; let __v_37: G = __v_10 + __v_36; let __v_38: G = __v_9 + __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = __v_7 + __v_8; let __v_41: G = __v_6 + __v_40; let __v_42: G = __v_5 + __v_41; let __v_43: G = G::from_bool(__v_42 == G::ZERO); let __v_44: G = G::from_u64(1); let __v_45: G = __v_44 - __v_43; let __v_46: G = __v_39 * __v_45; let __v_47: G = __v_44 - __v_46; if (__v_47 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 3] = [__v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_4, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_49, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_52, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_71, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __v_83: G = __r_arr[11]; let __v_84: G = __r_arr[12]; let __v_85: G = __r_arr[13]; let __v_86: G = __r_arr[14]; let __v_87: G = __r_arr[15]; let __v_88: G = __r_arr[16]; let __v_89: G = __r_arr[17]; let __v_90: G = __v_13 * __v_54; let __v_91: G = __v_15 * __v_55; let __v_92: G = __v_17 * __v_56; let __v_93: G = __v_19 * __v_57; let __v_94: G = __v_21 * __v_58; let __v_95: G = __v_23 * __v_59; let __v_96: G = __v_25 * __v_60; let __v_97: G = __v_95 + __v_96; let __v_98: G = __v_94 + __v_97; let __v_99: G = __v_93 + __v_98; let __v_100: G = __v_92 + __v_99; let __v_101: G = __v_91 + __v_100; let __v_102: G = __v_90 + __v_101; let __v_103: G = __v_53 + __v_102; let __v_104: G = __v_13 * __v_62; let __v_105: G = __v_15 * __v_63; let __v_106: G = __v_17 * __v_64; let __v_107: G = __v_19 * __v_65; let __v_108: G = __v_21 * __v_66; let __v_109: G = __v_23 * __v_67; let __v_110: G = __v_25 * __v_68; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_108 + __v_111; let __v_113: G = __v_107 + __v_112; let __v_114: G = __v_106 + __v_113; let __v_115: G = __v_105 + __v_114; let __v_116: G = __v_104 + __v_115; let __v_117: G = __v_61 + __v_116; let __v_118: G = __v_13 * __v_73; let __v_119: G = __v_15 * __v_74; let __v_120: G = __v_17 * __v_75; let __v_121: G = __v_19 * __v_76; let __v_122: G = __v_21 * __v_77; let __v_123: G = __v_23 * __v_78; let __v_124: G = __v_25 * __v_79; let __v_125: G = __v_123 + __v_124; let __v_126: G = __v_122 + __v_125; let __v_127: G = __v_121 + __v_126; let __v_128: G = __v_120 + __v_127; let __v_129: G = __v_119 + __v_128; let __v_130: G = __v_118 + __v_129; let __v_131: G = __v_72 + __v_130; let __v_132: G = __v_13 * __v_81; let __v_133: G = __v_15 * __v_82; let __v_134: G = __v_17 * __v_83; let __v_135: G = __v_19 * __v_84; let __v_136: G = __v_21 * __v_85; let __v_137: G = __v_23 * __v_86; let __v_138: G = __v_25 * __v_87; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_136 + __v_139; let __v_141: G = __v_135 + __v_140; let __v_142: G = __v_134 + __v_141; let __v_143: G = __v_133 + __v_142; let __v_144: G = __v_132 + __v_143; let __v_145: G = __v_80 + __v_144; let __ret: [G; OUT_214] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[214].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_215: usize = 2; const IN_215: usize = 2; const OUT_215: usize = 1; -fn aiur_fn_215(inp: [G; IN_215], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } 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_215] = [__v_8]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 => { if (__v_3 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_8]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_215(inp: [G; IN_215], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } 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_215] = [__v_8]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 => { if (__v_3 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_8]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_216: usize = 2; const IN_216: usize = 2; const OUT_216: usize = 1; -fn aiur_fn_216(inp: [G; IN_216], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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]; let __v_22: G = G::from_u64(1); if (__v_12 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_13 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_14 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_15 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_16 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_17 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_18 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_19 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_20 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_216] = [__v_22]; record.function_queries[216].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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 ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, (&__args[..]))?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { (*(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216])) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_216] = [__v_24]; record.function_queries[216].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_216(inp: [G; IN_216], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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]; let __v_22: G = G::from_u64(1); if (__v_12 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_13 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_14 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_15 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_16 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_17 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_18 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_19 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_20 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_216] = [__v_22]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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 ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, &__args[..])?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_216] = [__v_24]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_217: usize = 2; const IN_217: usize = 2; const OUT_217: usize = 1; -fn aiur_fn_217(inp: [G; IN_217], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } 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_217] = [__v_8]; record.function_queries[217].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, (&__args[..]))?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { (*(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216])) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, (&__args[..]))?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { (*(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217])) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_217] = [__v_10]; record.function_queries[217].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_217(inp: [G; IN_217], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } 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_217] = [__v_8]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, &__args[..])?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, &__args[..])?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_217] = [__v_10]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_218: usize = 2; const IN_218: usize = 2; const OUT_218: usize = 1; -fn aiur_fn_218(inp: [G; IN_218], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } 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_218] = [__v_8]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; let __v_43: G = __loaded[3]; let __v_44: G = __loaded[4]; let __v_45: G = __loaded[5]; let __v_46: G = __loaded[6]; let __v_47: G = __loaded[7]; let __v_48: G = __loaded[8]; let __v_49: G = __loaded[9]; let __v_50: G = __loaded[10]; let __v_51: G = __loaded[11]; let __v_52: G = __loaded[12]; let __v_53: G = __loaded[13]; let __v_54: G = __loaded[14]; let __v_55: G = __loaded[15]; let __v_56: G = __loaded[16]; let __v_57: G = __loaded[17]; let __v_58: G = __loaded[18]; let __v_59: G = __loaded[19]; let __v_60: G = __loaded[20]; let __v_61: G = __loaded[21]; let __v_62: G = __loaded[22]; let __v_63: G = __loaded[23]; let __v_64: G = __loaded[24]; let __v_65: G = __loaded[25]; let __v_66: G = __loaded[26]; let __v_67: G = __loaded[27]; let __v_68: G = __loaded[28]; let __v_69: G = __loaded[29]; let __v_70: G = __loaded[30]; let __v_71: G = __loaded[31]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; 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_10] = { let __args: [G; IN_10] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; if (__v_74 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; if (__v_75 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; if (__v_76 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, (&__args[..]))?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { (*(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218])) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_77]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_218(inp: [G; IN_218], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } 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_218] = [__v_8]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; let __v_43: G = __loaded[3]; let __v_44: G = __loaded[4]; let __v_45: G = __loaded[5]; let __v_46: G = __loaded[6]; let __v_47: G = __loaded[7]; let __v_48: G = __loaded[8]; let __v_49: G = __loaded[9]; let __v_50: G = __loaded[10]; let __v_51: G = __loaded[11]; let __v_52: G = __loaded[12]; let __v_53: G = __loaded[13]; let __v_54: G = __loaded[14]; let __v_55: G = __loaded[15]; let __v_56: G = __loaded[16]; let __v_57: G = __loaded[17]; let __v_58: G = __loaded[18]; let __v_59: G = __loaded[19]; let __v_60: G = __loaded[20]; let __v_61: G = __loaded[21]; let __v_62: G = __loaded[22]; let __v_63: G = __loaded[23]; let __v_64: G = __loaded[24]; let __v_65: G = __loaded[25]; let __v_66: G = __loaded[26]; let __v_67: G = __loaded[27]; let __v_68: G = __loaded[28]; let __v_69: G = __loaded[29]; let __v_70: G = __loaded[30]; let __v_71: G = __loaded[31]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; 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_10] = { let __args: [G; IN_10] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; if (__v_74 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; if (__v_75 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; if (__v_76 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, &__args[..])?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_77]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_219: usize = 1; const IN_219: usize = 1; const OUT_219: usize = 2; -fn aiur_fn_219(inp: [G; IN_219], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_219] = [__v_2, __v_3]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, (&__args[..]))?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { (*(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219])) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_219] = [__v_9, __v_10]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_219(inp: [G; IN_219], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_219] = [__v_2, __v_3]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, &__args[..])?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_219] = [__v_9, __v_10]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_220: usize = 7; const IN_220: usize = 7; const OUT_220: usize = 2; -fn aiur_fn_220(inp: [G; IN_220], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_220] = [__v_0, __v_1]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, (&__args[..]))?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { (*(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201])) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = (__v_3 + __v_18); let __v_21: G = (__v_4 + __v_19); let __v_22: G = (__v_20 * __v_20); let __v_23: G = G::from_u64(7); let __v_24: G = (__v_21 * __v_21); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_22 - __v_25); let __v_27: G = aiur::execute::g_inverse_value(__v_26); let __v_28: G = (__v_26 * __v_27); let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = (__v_26 * __v_30); let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_33: G = (__v_27 * __v_30); if (__v_33 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_34: G = (__v_20 * __v_27); let __v_35: G = (__v_32 - __v_21); let __v_36: G = (__v_35 * __v_27); let __v_37: G = G::from_u64(256); let __v_38: G = (__v_37 * __v_10); let __v_39: G = G::from_u64(65536); let __v_40: G = (__v_39 * __v_11); let __v_41: G = G::from_u64(16777216); let __v_42: G = (__v_41 * __v_12); let __v_43: G = G::from_u64(4294967296); let __v_44: G = (__v_43 * __v_13); let __v_45: G = G::from_u64(1099511627776); let __v_46: G = (__v_45 * __v_14); let __v_47: G = G::from_u64(281474976710656); let __v_48: G = (__v_47 * __v_15); let __v_49: G = G::from_u64(72057594037927936); let __v_50: G = (__v_49 * __v_16); let __v_51: G = (__v_48 + __v_50); let __v_52: G = (__v_46 + __v_51); let __v_53: G = (__v_44 + __v_52); let __v_54: G = (__v_42 + __v_53); let __v_55: G = (__v_40 + __v_54); let __v_56: G = (__v_38 + __v_55); let __v_57: G = (__v_9 + __v_56); let __v_58: G = (__v_34 * __v_57); let __v_59: G = (__v_36 * __v_32); let __v_60: G = (__v_23 * __v_59); let __v_61: G = (__v_58 + __v_60); let __v_62: G = (__v_34 * __v_32); let __v_63: G = (__v_36 * __v_57); let __v_64: G = (__v_62 + __v_63); let __v_65: G = (__v_0 + __v_61); let __v_66: G = (__v_1 + __v_64); let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, (&__args[..]))?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { (*(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220])) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_220] = [__v_67, __v_68]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_220(inp: [G; IN_220], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_220] = [__v_0, __v_1]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, &__args[..])?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __v_3 + __v_18; let __v_21: G = __v_4 + __v_19; let __v_22: G = __v_20 * __v_20; let __v_23: G = G::from_u64(7); let __v_24: G = __v_21 * __v_21; let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_22 - __v_25; let __v_27: G = aiur::execute::g_inverse_value(__v_26); let __v_28: G = __v_26 * __v_27; let __v_29: G = G::from_u64(1); let __v_30: G = __v_28 - __v_29; let __v_31: G = __v_26 * __v_30; let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_33: G = __v_27 * __v_30; if (__v_33 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_34: G = __v_20 * __v_27; let __v_35: G = __v_32 - __v_21; let __v_36: G = __v_35 * __v_27; let __v_37: G = G::from_u64(256); let __v_38: G = __v_37 * __v_10; let __v_39: G = G::from_u64(65536); let __v_40: G = __v_39 * __v_11; let __v_41: G = G::from_u64(16777216); let __v_42: G = __v_41 * __v_12; let __v_43: G = G::from_u64(4294967296); let __v_44: G = __v_43 * __v_13; let __v_45: G = G::from_u64(1099511627776); let __v_46: G = __v_45 * __v_14; let __v_47: G = G::from_u64(281474976710656); let __v_48: G = __v_47 * __v_15; let __v_49: G = G::from_u64(72057594037927936); let __v_50: G = __v_49 * __v_16; let __v_51: G = __v_48 + __v_50; let __v_52: G = __v_46 + __v_51; let __v_53: G = __v_44 + __v_52; let __v_54: G = __v_42 + __v_53; let __v_55: G = __v_40 + __v_54; let __v_56: G = __v_38 + __v_55; let __v_57: G = __v_9 + __v_56; let __v_58: G = __v_34 * __v_57; let __v_59: G = __v_36 * __v_32; let __v_60: G = __v_23 * __v_59; let __v_61: G = __v_58 + __v_60; let __v_62: G = __v_34 * __v_32; let __v_63: G = __v_36 * __v_57; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_0 + __v_61; let __v_66: G = __v_1 + __v_64; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, &__args[..])?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_220] = [__v_67, __v_68]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_221: usize = 1; const IN_221: usize = 1; const OUT_221: usize = 1; -fn aiur_fn_221(inp: [G; IN_221], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; 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_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_221(inp: [G; IN_221], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; 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_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_222: usize = 1; const IN_222: usize = 1; const OUT_222: usize = 1; -fn aiur_fn_222(inp: [G; IN_222], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_222] = [__v_4]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, (&__args[..]))?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { (*(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221])) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, (&__args[..]))?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { (*(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222])) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_222] = [__v_6]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_222(inp: [G; IN_222], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_222] = [__v_4]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, &__args[..])?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, &__args[..])?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_222] = [__v_6]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_223: usize = 1; const IN_223: usize = 1; const OUT_223: usize = 1; -fn aiur_fn_223(inp: [G; IN_223], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_223] = [__v_4]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, (&__args[..]))?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { (*(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223])) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_2 + __v_4); let __ret: [G; OUT_223] = [__v_5]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_223(inp: [G; IN_223], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_223] = [__v_4]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, &__args[..])?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_2 + __v_4; let __ret: [G; OUT_223] = [__v_5]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_224: usize = 1; const IN_224: usize = 1; const OUT_224: usize = 1; -fn aiur_fn_224(inp: [G; IN_224], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_bool((__v_0 == G::ZERO)); let __v_2: G = G::from_u64(0); if (__v_1 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_3: G = G::from_u8(__gb[0]); let __v_4: G = G::from_u8(__gb[1]); let __v_5: G = G::from_u8(__gb[2]); let __v_6: G = G::from_u8(__gb[3]); let __v_7: G = G::from_u8(__gb[4]); let __v_8: G = G::from_u8(__gb[5]); let __v_9: G = G::from_u8(__gb[6]); let __v_10: G = G::from_u8(__gb[7]); 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)); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; 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(256); let __v_12: G = (__v_11 * __v_4); let __v_13: G = G::from_u64(65536); let __v_14: G = (__v_13 * __v_5); let __v_15: G = G::from_u64(16777216); let __v_16: G = (__v_15 * __v_6); let __v_17: G = G::from_u64(4294967296); let __v_18: G = (__v_17 * __v_7); let __v_19: G = G::from_u64(1099511627776); let __v_20: G = (__v_19 * __v_8); let __v_21: G = G::from_u64(281474976710656); let __v_22: G = (__v_21 * __v_9); let __v_23: G = G::from_u64(72057594037927936); let __v_24: G = (__v_23 * __v_10); let __v_25: G = (__v_22 + __v_24); let __v_26: G = (__v_20 + __v_25); let __v_27: G = (__v_18 + __v_26); let __v_28: G = (__v_16 + __v_27); let __v_29: G = (__v_14 + __v_28); let __v_30: G = (__v_12 + __v_29); let __v_31: G = (__v_3 + __v_30); if (__v_31 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(1020); let __v_33: G = (__v_10 - __v_32); let __v_34: G = (__v_9 + __v_33); let __v_35: G = (__v_8 + __v_34); let __v_36: G = (__v_7 + __v_35); let __v_37: G = G::from_bool((__v_36 == G::ZERO)); let __v_38: G = (__v_5 + __v_6); let __v_39: G = (__v_4 + __v_38); let __v_40: G = (__v_3 + __v_39); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = G::from_u64(1); let __v_43: G = (__v_42 - __v_41); let __v_44: G = (__v_37 * __v_43); let __v_45: G = (__v_42 - __v_44); if (__v_45 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_46: G = (__v_9 + __v_10); let __v_47: G = (__v_8 + __v_46); let __v_48: G = (__v_7 + __v_47); let __v_49: G = (__v_6 + __v_48); if (__v_49 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_50: G = (__v_5 - __v_42); let __v_51: G = (__v_5 * __v_50); if (__v_51 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_52: G = (__v_3 + __v_4); let __v_53: G = (__v_5 * __v_52); if (__v_53 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_224] = [__v_42]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_224(inp: [G; IN_224], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_bool(__v_0 == G::ZERO); let __v_2: G = G::from_u64(0); if (__v_1 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_3: G = G::from_u8(__gb[0]); let __v_4: G = G::from_u8(__gb[1]); let __v_5: G = G::from_u8(__gb[2]); let __v_6: G = G::from_u8(__gb[3]); let __v_7: G = G::from_u8(__gb[4]); let __v_8: G = G::from_u8(__gb[5]); let __v_9: G = G::from_u8(__gb[6]); let __v_10: G = G::from_u8(__gb[7]); 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); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; 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(256); let __v_12: G = __v_11 * __v_4; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_5; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_6; let __v_17: G = G::from_u64(4294967296); let __v_18: G = __v_17 * __v_7; let __v_19: G = G::from_u64(1099511627776); let __v_20: G = __v_19 * __v_8; let __v_21: G = G::from_u64(281474976710656); let __v_22: G = __v_21 * __v_9; let __v_23: G = G::from_u64(72057594037927936); let __v_24: G = __v_23 * __v_10; let __v_25: G = __v_22 + __v_24; let __v_26: G = __v_20 + __v_25; let __v_27: G = __v_18 + __v_26; let __v_28: G = __v_16 + __v_27; let __v_29: G = __v_14 + __v_28; let __v_30: G = __v_12 + __v_29; let __v_31: G = __v_3 + __v_30; if (__v_31 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(1020); let __v_33: G = __v_10 - __v_32; let __v_34: G = __v_9 + __v_33; let __v_35: G = __v_8 + __v_34; let __v_36: G = __v_7 + __v_35; let __v_37: G = G::from_bool(__v_36 == G::ZERO); let __v_38: G = __v_5 + __v_6; let __v_39: G = __v_4 + __v_38; let __v_40: G = __v_3 + __v_39; let __v_41: G = G::from_bool(__v_40 == G::ZERO); let __v_42: G = G::from_u64(1); let __v_43: G = __v_42 - __v_41; let __v_44: G = __v_37 * __v_43; let __v_45: G = __v_42 - __v_44; if (__v_45 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_46: G = __v_9 + __v_10; let __v_47: G = __v_8 + __v_46; let __v_48: G = __v_7 + __v_47; let __v_49: G = __v_6 + __v_48; if (__v_49 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_50: G = __v_5 - __v_42; let __v_51: G = __v_5 * __v_50; if (__v_51 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_52: G = __v_3 + __v_4; let __v_53: G = __v_5 * __v_52; if (__v_53 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_224] = [__v_42]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_225: usize = 1; const IN_225: usize = 1; const OUT_225: usize = 24; -fn aiur_fn_225(inp: [G; IN_225], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; let __v_25: G = __loaded[4]; let __v_26: G = __loaded[5]; let __v_27: G = __loaded[6]; let __v_28: G = __loaded[7]; let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; match __v_21.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = G::from_u64(1); if (__v_31 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_32 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_33 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_34 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_35 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_36 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_37 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_38 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_39 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_40 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_225] = [__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_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; record.function_queries[225].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_225(inp: [G; IN_225], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; let __v_25: G = __loaded[4]; let __v_26: G = __loaded[5]; let __v_27: G = __loaded[6]; let __v_28: G = __loaded[7]; let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; match __v_21.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = G::from_u64(1); if (__v_31 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_32 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_33 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_34 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_35 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_36 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_37 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_38 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_39 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_40 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_225] = [__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_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_226: usize = 3; const IN_226: usize = 3; const OUT_226: usize = 1; -fn aiur_fn_226(inp: [G; IN_226], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_0), (&__v_1)) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_1, record) }; let __v_4: G = (__v_0 - __v_1); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); let __v_6: G = (__v_5 * __v_2); let __v_7: G = (__v_3 + __v_6); let __ret: [G; OUT_226] = [__v_7]; record.function_queries[226].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_226(inp: [G; IN_226], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_1) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_1, record) }; let __v_4: G = __v_0 - __v_1; let __v_5: G = G::from_bool(__v_4 == G::ZERO); let __v_6: G = __v_5 * __v_2; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_226] = [__v_7]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_227: usize = 16; const IN_227: usize = 16; const OUT_227: usize = 1; -fn aiur_fn_227(inp: [G; IN_227], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 = G::from_u64(1); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1, __v_9, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_10, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __v_12, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_5, __v_13, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_15, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_24]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_227(inp: [G; IN_227], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 = G::from_u64(1); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1, __v_9, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_10, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __v_12, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_5, __v_13, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_15, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_24]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_228: usize = 3; const IN_228: usize = 3; const OUT_228: usize = 1; -fn aiur_fn_228(inp: [G; IN_228], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_228] = [__v_14]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; let __v_20: G = __loaded[6]; let __v_21: G = __loaded[7]; let __v_22: G = __loaded[8]; let __v_23: G = __loaded[9]; let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { _ => { match __v_15.as_canonical_u64() { _ => { let __v_25: G = G::from_u64(256); let __v_26: G = (__v_25 * __v_6); let __v_27: G = G::from_u64(65536); let __v_28: G = (__v_27 * __v_7); let __v_29: G = G::from_u64(16777216); let __v_30: G = (__v_29 * __v_8); let __v_31: G = G::from_u64(4294967296); let __v_32: G = (__v_31 * __v_9); let __v_33: G = G::from_u64(1099511627776); let __v_34: G = (__v_33 * __v_10); let __v_35: G = G::from_u64(281474976710656); let __v_36: G = (__v_35 * __v_11); let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = (__v_37 * __v_12); let __v_39: G = (__v_36 + __v_38); let __v_40: G = (__v_34 + __v_39); let __v_41: G = (__v_32 + __v_40); let __v_42: G = (__v_30 + __v_41); let __v_43: G = (__v_28 + __v_42); let __v_44: G = (__v_26 + __v_43); let __v_45: G = (__v_5 + __v_44); let __v_46: G = G::from_u64(1); let __v_47: G = (__v_45 + __v_46); let __v_48: G = G::from_u64(0); if (__v_47 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __v_49: G = (__v_25 * __v_17); let __v_50: G = (__v_27 * __v_18); let __v_51: G = (__v_29 * __v_19); let __v_52: G = (__v_31 * __v_20); let __v_53: G = (__v_33 * __v_21); let __v_54: G = (__v_35 * __v_22); let __v_55: G = (__v_37 * __v_23); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_53 + __v_56); let __v_58: G = (__v_52 + __v_57); let __v_59: G = (__v_51 + __v_58); let __v_60: G = (__v_50 + __v_59); let __v_61: G = (__v_49 + __v_60); let __v_62: G = (__v_16 + __v_61); if (__v_62 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, (&__args[..]))?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { (*(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225])) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __v_67: G = __r_arr[4]; let __v_68: G = __r_arr[5]; let __v_69: G = __r_arr[6]; let __v_70: G = __r_arr[7]; let __v_71: G = __r_arr[8]; let __v_72: G = __r_arr[9]; let __v_73: G = __r_arr[10]; let __v_74: G = __r_arr[11]; let __v_75: G = __r_arr[12]; let __v_76: G = __r_arr[13]; let __v_77: G = __r_arr[14]; let __v_78: G = __r_arr[15]; let __v_79: G = __r_arr[16]; let __v_80: G = __r_arr[17]; let __v_81: G = __r_arr[18]; let __v_82: G = __r_arr[19]; let __v_83: G = __r_arr[20]; let __v_84: G = __r_arr[21]; let __v_85: G = __r_arr[22]; let __v_86: G = __r_arr[23]; let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, (&__args[..]))?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { (*(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225])) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = __r_arr[3]; let __v_91: G = __r_arr[4]; let __v_92: G = __r_arr[5]; let __v_93: G = __r_arr[6]; let __v_94: G = __r_arr[7]; let __v_95: G = __r_arr[8]; let __v_96: G = __r_arr[9]; let __v_97: G = __r_arr[10]; let __v_98: G = __r_arr[11]; let __v_99: G = __r_arr[12]; let __v_100: G = __r_arr[13]; let __v_101: G = __r_arr[14]; let __v_102: G = __r_arr[15]; let __v_103: G = __r_arr[16]; let __v_104: G = __r_arr[17]; let __v_105: G = __r_arr[18]; let __v_106: G = __r_arr[19]; let __v_107: G = __r_arr[20]; let __v_108: G = __r_arr[21]; let __v_109: G = __r_arr[22]; let __v_110: G = __r_arr[23]; let __v_111: G = (__v_25 * __v_64); let __v_112: G = (__v_27 * __v_65); let __v_113: G = (__v_29 * __v_66); let __v_114: G = (__v_31 * __v_67); let __v_115: G = (__v_33 * __v_68); let __v_116: G = (__v_35 * __v_69); let __v_117: G = (__v_37 * __v_70); let __v_118: G = (__v_116 + __v_117); let __v_119: G = (__v_115 + __v_118); let __v_120: G = (__v_114 + __v_119); let __v_121: G = (__v_113 + __v_120); let __v_122: G = (__v_112 + __v_121); let __v_123: G = (__v_111 + __v_122); let __v_124: G = (__v_63 + __v_123); let __v_125: G = G::from_u64(16); if (__v_124 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_124.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_25 * __v_88); let __v_127: G = (__v_27 * __v_89); let __v_128: G = (__v_29 * __v_90); let __v_129: G = (__v_31 * __v_91); let __v_130: G = (__v_33 * __v_92); let __v_131: G = (__v_35 * __v_93); let __v_132: G = (__v_37 * __v_94); let __v_133: G = (__v_131 + __v_132); let __v_134: G = (__v_130 + __v_133); let __v_135: G = (__v_129 + __v_134); let __v_136: G = (__v_128 + __v_135); let __v_137: G = (__v_127 + __v_136); let __v_138: G = (__v_126 + __v_137); let __v_139: G = (__v_87 + __v_138); if (__v_139 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_140: G = (__v_25 * __v_72); let __v_141: G = (__v_27 * __v_73); let __v_142: G = (__v_29 * __v_74); let __v_143: G = (__v_31 * __v_75); let __v_144: G = (__v_33 * __v_76); let __v_145: G = (__v_35 * __v_77); let __v_146: G = (__v_37 * __v_78); let __v_147: G = (__v_145 + __v_146); let __v_148: G = (__v_144 + __v_147); let __v_149: G = (__v_143 + __v_148); let __v_150: G = (__v_142 + __v_149); let __v_151: G = (__v_141 + __v_150); let __v_152: G = (__v_140 + __v_151); let __v_153: G = (__v_71 + __v_152); let __v_154: G = (__v_25 * __v_96); let __v_155: G = (__v_27 * __v_97); let __v_156: G = (__v_29 * __v_98); let __v_157: G = (__v_31 * __v_99); let __v_158: G = (__v_33 * __v_100); let __v_159: G = (__v_35 * __v_101); let __v_160: G = (__v_37 * __v_102); let __v_161: G = (__v_159 + __v_160); let __v_162: G = (__v_158 + __v_161); let __v_163: G = (__v_157 + __v_162); let __v_164: G = (__v_156 + __v_163); let __v_165: G = (__v_155 + __v_164); let __v_166: G = (__v_154 + __v_165); let __v_167: G = (__v_95 + __v_166); if (__v_167 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_168: G = (__v_25 * __v_80); let __v_169: G = (__v_27 * __v_81); let __v_170: G = (__v_29 * __v_82); let __v_171: G = (__v_31 * __v_83); let __v_172: G = (__v_33 * __v_84); let __v_173: G = (__v_35 * __v_85); let __v_174: G = (__v_37 * __v_86); let __v_175: G = (__v_173 + __v_174); let __v_176: G = (__v_172 + __v_175); let __v_177: G = (__v_171 + __v_176); let __v_178: G = (__v_170 + __v_177); let __v_179: G = (__v_169 + __v_178); let __v_180: G = (__v_168 + __v_179); let __v_181: G = (__v_79 + __v_180); let __v_182: G = (__v_25 * __v_104); let __v_183: G = (__v_27 * __v_105); let __v_184: G = (__v_29 * __v_106); let __v_185: G = (__v_31 * __v_107); let __v_186: G = (__v_33 * __v_108); let __v_187: G = (__v_35 * __v_109); let __v_188: G = (__v_37 * __v_110); let __v_189: G = (__v_187 + __v_188); let __v_190: G = (__v_186 + __v_189); let __v_191: G = (__v_185 + __v_190); let __v_192: G = (__v_184 + __v_191); let __v_193: G = (__v_183 + __v_192); let __v_194: G = (__v_182 + __v_193); let __v_195: G = (__v_103 + __v_194); let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_196: G = G::from_u8(__gb[0]); let __v_197: G = G::from_u8(__gb[1]); let __v_198: G = G::from_u8(__gb[2]); let __v_199: G = G::from_u8(__gb[3]); let __v_200: G = G::from_u8(__gb[4]); let __v_201: G = G::from_u8(__gb[5]); let __v_202: G = G::from_u8(__gb[6]); let __v_203: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; 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_198; let __vj = __v_199; 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_200; let __vj = __v_201; 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_202; let __vj = __v_203; 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_204: G = (__v_25 * __v_197); let __v_205: G = (__v_27 * __v_198); let __v_206: G = (__v_29 * __v_199); let __v_207: G = (__v_31 * __v_200); let __v_208: G = (__v_33 * __v_201); let __v_209: G = (__v_35 * __v_202); let __v_210: G = (__v_37 * __v_203); let __v_211: G = (__v_209 + __v_210); let __v_212: G = (__v_208 + __v_211); let __v_213: G = (__v_207 + __v_212); let __v_214: G = (__v_206 + __v_213); let __v_215: G = (__v_205 + __v_214); let __v_216: G = (__v_204 + __v_215); let __v_217: G = (__v_196 + __v_216); if (__v_217 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_218: G = G::from_u64(1020); let __v_219: G = (__v_203 - __v_218); let __v_220: G = (__v_202 + __v_219); let __v_221: G = (__v_201 + __v_220); let __v_222: G = (__v_200 + __v_221); let __v_223: G = G::from_bool((__v_222 == G::ZERO)); let __v_224: G = (__v_198 + __v_199); let __v_225: G = (__v_197 + __v_224); let __v_226: G = (__v_196 + __v_225); let __v_227: G = G::from_bool((__v_226 == G::ZERO)); let __v_228: G = (__v_46 - __v_227); let __v_229: G = (__v_223 * __v_228); let __v_230: G = (__v_46 - __v_229); if (__v_230 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_195.as_canonical_u64().to_le_bytes(); let __v_231: G = G::from_u8(__gb[0]); let __v_232: G = G::from_u8(__gb[1]); let __v_233: G = G::from_u8(__gb[2]); let __v_234: G = G::from_u8(__gb[3]); let __v_235: G = G::from_u8(__gb[4]); let __v_236: G = G::from_u8(__gb[5]); let __v_237: G = G::from_u8(__gb[6]); let __v_238: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_231; let __vj = __v_232; 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_233; let __vj = __v_234; 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_235; let __vj = __v_236; 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_237; let __vj = __v_238; 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_239: G = (__v_25 * __v_232); let __v_240: G = (__v_27 * __v_233); let __v_241: G = (__v_29 * __v_234); let __v_242: G = (__v_31 * __v_235); let __v_243: G = (__v_33 * __v_236); let __v_244: G = (__v_35 * __v_237); let __v_245: G = (__v_37 * __v_238); let __v_246: G = (__v_244 + __v_245); let __v_247: G = (__v_243 + __v_246); let __v_248: G = (__v_242 + __v_247); let __v_249: G = (__v_241 + __v_248); let __v_250: G = (__v_240 + __v_249); let __v_251: G = (__v_239 + __v_250); let __v_252: G = (__v_231 + __v_251); if (__v_252 != __v_195) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_195.as_canonical_u64(), msg: None }); } let __v_253: G = (__v_238 - __v_218); let __v_254: G = (__v_237 + __v_253); let __v_255: G = (__v_236 + __v_254); let __v_256: G = (__v_235 + __v_255); let __v_257: G = G::from_bool((__v_256 == G::ZERO)); let __v_258: G = (__v_233 + __v_234); let __v_259: G = (__v_232 + __v_258); let __v_260: G = (__v_231 + __v_259); let __v_261: G = G::from_bool((__v_260 == G::ZERO)); let __v_262: G = (__v_46 - __v_261); let __v_263: G = (__v_257 * __v_262); let __v_264: G = (__v_46 - __v_263); if (__v_264 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, (&__args[..]))?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { (*(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227])) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_265: G = __r_arr[0]; if (__v_265 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_265.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_266: G = (__v_153 - __v_1); let __v_267: G = G::from_bool((__v_266 == G::ZERO)); let __gb: [u8; 8] = __v_153.as_canonical_u64().to_le_bytes(); let __v_268: G = G::from_u8(__gb[0]); let __v_269: G = G::from_u8(__gb[1]); let __v_270: G = G::from_u8(__gb[2]); let __v_271: G = G::from_u8(__gb[3]); let __v_272: G = G::from_u8(__gb[4]); let __v_273: G = G::from_u8(__gb[5]); let __v_274: G = G::from_u8(__gb[6]); let __v_275: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; 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_270; let __vj = __v_271; 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_272; let __vj = __v_273; 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_274; let __vj = __v_275; 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_276: G = (__v_25 * __v_269); let __v_277: G = (__v_27 * __v_270); let __v_278: G = (__v_29 * __v_271); let __v_279: G = (__v_31 * __v_272); let __v_280: G = (__v_33 * __v_273); let __v_281: G = (__v_35 * __v_274); let __v_282: G = (__v_37 * __v_275); let __v_283: G = (__v_281 + __v_282); let __v_284: G = (__v_280 + __v_283); let __v_285: G = (__v_279 + __v_284); let __v_286: G = (__v_278 + __v_285); let __v_287: G = (__v_277 + __v_286); let __v_288: G = (__v_276 + __v_287); let __v_289: G = (__v_268 + __v_288); if (__v_289 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_289.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_290: G = (__v_275 - __v_218); let __v_291: G = (__v_274 + __v_290); let __v_292: G = (__v_273 + __v_291); let __v_293: G = (__v_272 + __v_292); let __v_294: G = G::from_bool((__v_293 == G::ZERO)); let __v_295: G = (__v_270 + __v_271); let __v_296: G = (__v_269 + __v_295); let __v_297: G = (__v_268 + __v_296); let __v_298: G = G::from_bool((__v_297 == G::ZERO)); let __v_299: G = (__v_46 - __v_298); let __v_300: G = (__v_294 * __v_299); let __v_301: G = (__v_46 - __v_300); if (__v_301 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_301.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_302: G = G::from_u8(__gb[0]); let __v_303: G = G::from_u8(__gb[1]); let __v_304: G = G::from_u8(__gb[2]); let __v_305: G = G::from_u8(__gb[3]); let __v_306: G = G::from_u8(__gb[4]); let __v_307: G = G::from_u8(__gb[5]); let __v_308: G = G::from_u8(__gb[6]); let __v_309: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; 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_304; let __vj = __v_305; 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_306; let __vj = __v_307; 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_308; let __vj = __v_309; 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_310: G = (__v_25 * __v_303); let __v_311: G = (__v_27 * __v_304); let __v_312: G = (__v_29 * __v_305); let __v_313: G = (__v_31 * __v_306); let __v_314: G = (__v_33 * __v_307); let __v_315: G = (__v_35 * __v_308); let __v_316: G = (__v_37 * __v_309); let __v_317: G = (__v_315 + __v_316); let __v_318: G = (__v_314 + __v_317); let __v_319: G = (__v_313 + __v_318); let __v_320: G = (__v_312 + __v_319); let __v_321: G = (__v_311 + __v_320); let __v_322: G = (__v_310 + __v_321); let __v_323: G = (__v_302 + __v_322); if (__v_323 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_323.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_324: G = (__v_309 - __v_218); let __v_325: G = (__v_308 + __v_324); let __v_326: G = (__v_307 + __v_325); let __v_327: G = (__v_306 + __v_326); let __v_328: G = G::from_bool((__v_327 == G::ZERO)); let __v_329: G = (__v_304 + __v_305); let __v_330: G = (__v_303 + __v_329); let __v_331: G = (__v_302 + __v_330); let __v_332: G = G::from_bool((__v_331 == G::ZERO)); let __v_333: G = (__v_46 - __v_332); let __v_334: G = (__v_328 * __v_333); let __v_335: G = (__v_46 - __v_334); if (__v_335 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, (&__args[..]))?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { (*(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227])) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_336: G = __r_arr[0]; let __v_337: G = (__v_46 - __v_336); let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_338: G = G::from_u8(__gb[0]); let __v_339: G = G::from_u8(__gb[1]); let __v_340: G = G::from_u8(__gb[2]); let __v_341: G = G::from_u8(__gb[3]); let __v_342: G = G::from_u8(__gb[4]); let __v_343: G = G::from_u8(__gb[5]); let __v_344: G = G::from_u8(__gb[6]); let __v_345: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_338; let __vj = __v_339; 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_340; let __vj = __v_341; 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_342; let __vj = __v_343; 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_344; let __vj = __v_345; 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_346: G = (__v_25 * __v_339); let __v_347: G = (__v_27 * __v_340); let __v_348: G = (__v_29 * __v_341); let __v_349: G = (__v_31 * __v_342); let __v_350: G = (__v_33 * __v_343); let __v_351: G = (__v_35 * __v_344); let __v_352: G = (__v_37 * __v_345); let __v_353: G = (__v_351 + __v_352); let __v_354: G = (__v_350 + __v_353); let __v_355: G = (__v_349 + __v_354); let __v_356: G = (__v_348 + __v_355); let __v_357: G = (__v_347 + __v_356); let __v_358: G = (__v_346 + __v_357); let __v_359: G = (__v_338 + __v_358); if (__v_359 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_360: G = (__v_345 - __v_218); let __v_361: G = (__v_344 + __v_360); let __v_362: G = (__v_343 + __v_361); let __v_363: G = (__v_342 + __v_362); let __v_364: G = G::from_bool((__v_363 == G::ZERO)); let __v_365: G = (__v_340 + __v_341); let __v_366: G = (__v_339 + __v_365); let __v_367: G = (__v_338 + __v_366); let __v_368: G = G::from_bool((__v_367 == G::ZERO)); let __v_369: G = (__v_46 - __v_368); let __v_370: G = (__v_364 * __v_369); let __v_371: G = (__v_46 - __v_370); if (__v_371 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_372: G = G::from_u8(__gb[0]); let __v_373: G = G::from_u8(__gb[1]); let __v_374: G = G::from_u8(__gb[2]); let __v_375: G = G::from_u8(__gb[3]); let __v_376: G = G::from_u8(__gb[4]); let __v_377: G = G::from_u8(__gb[5]); let __v_378: G = G::from_u8(__gb[6]); let __v_379: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_372; let __vj = __v_373; 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_374; let __vj = __v_375; 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_376; let __vj = __v_377; 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_378; let __vj = __v_379; 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_380: G = (__v_25 * __v_373); let __v_381: G = (__v_27 * __v_374); let __v_382: G = (__v_29 * __v_375); let __v_383: G = (__v_31 * __v_376); let __v_384: G = (__v_33 * __v_377); let __v_385: G = (__v_35 * __v_378); let __v_386: G = (__v_37 * __v_379); let __v_387: G = (__v_385 + __v_386); let __v_388: G = (__v_384 + __v_387); let __v_389: G = (__v_383 + __v_388); let __v_390: G = (__v_382 + __v_389); let __v_391: G = (__v_381 + __v_390); let __v_392: G = (__v_380 + __v_391); let __v_393: G = (__v_372 + __v_392); if (__v_393 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_393.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_394: G = (__v_379 - __v_218); let __v_395: G = (__v_378 + __v_394); let __v_396: G = (__v_377 + __v_395); let __v_397: G = (__v_376 + __v_396); let __v_398: G = G::from_bool((__v_397 == G::ZERO)); let __v_399: G = (__v_374 + __v_375); let __v_400: G = (__v_373 + __v_399); let __v_401: G = (__v_372 + __v_400); let __v_402: G = G::from_bool((__v_401 == G::ZERO)); let __v_403: G = (__v_46 - __v_402); let __v_404: G = (__v_398 * __v_403); let __v_405: G = (__v_46 - __v_404); if (__v_405 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_378, __v_379]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, (&__args[..]))?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { (*(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227])) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_406: G = __r_arr[0]; let __v_407: G = (__v_267 * __v_406); let __v_408: G = (__v_337 + __v_407); if (__v_408 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_24, __v_153, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, (&__args[..]))?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { (*(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228])) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_409: G = __r_arr[0]; let __ret: [G; OUT_228] = [__v_409]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_228(inp: [G; IN_228], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_228] = [__v_14]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; let __v_20: G = __loaded[6]; let __v_21: G = __loaded[7]; let __v_22: G = __loaded[8]; let __v_23: G = __loaded[9]; let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { _ => { match __v_15.as_canonical_u64() { _ => { let __v_25: G = G::from_u64(256); let __v_26: G = __v_25 * __v_6; let __v_27: G = G::from_u64(65536); let __v_28: G = __v_27 * __v_7; let __v_29: G = G::from_u64(16777216); let __v_30: G = __v_29 * __v_8; let __v_31: G = G::from_u64(4294967296); let __v_32: G = __v_31 * __v_9; let __v_33: G = G::from_u64(1099511627776); let __v_34: G = __v_33 * __v_10; let __v_35: G = G::from_u64(281474976710656); let __v_36: G = __v_35 * __v_11; let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = __v_37 * __v_12; let __v_39: G = __v_36 + __v_38; let __v_40: G = __v_34 + __v_39; let __v_41: G = __v_32 + __v_40; let __v_42: G = __v_30 + __v_41; let __v_43: G = __v_28 + __v_42; let __v_44: G = __v_26 + __v_43; let __v_45: G = __v_5 + __v_44; let __v_46: G = G::from_u64(1); let __v_47: G = __v_45 + __v_46; let __v_48: G = G::from_u64(0); if (__v_47 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __v_49: G = __v_25 * __v_17; let __v_50: G = __v_27 * __v_18; let __v_51: G = __v_29 * __v_19; let __v_52: G = __v_31 * __v_20; let __v_53: G = __v_33 * __v_21; let __v_54: G = __v_35 * __v_22; let __v_55: G = __v_37 * __v_23; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_53 + __v_56; let __v_58: G = __v_52 + __v_57; let __v_59: G = __v_51 + __v_58; let __v_60: G = __v_50 + __v_59; let __v_61: G = __v_49 + __v_60; let __v_62: G = __v_16 + __v_61; if (__v_62 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, &__args[..])?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __v_67: G = __r_arr[4]; let __v_68: G = __r_arr[5]; let __v_69: G = __r_arr[6]; let __v_70: G = __r_arr[7]; let __v_71: G = __r_arr[8]; let __v_72: G = __r_arr[9]; let __v_73: G = __r_arr[10]; let __v_74: G = __r_arr[11]; let __v_75: G = __r_arr[12]; let __v_76: G = __r_arr[13]; let __v_77: G = __r_arr[14]; let __v_78: G = __r_arr[15]; let __v_79: G = __r_arr[16]; let __v_80: G = __r_arr[17]; let __v_81: G = __r_arr[18]; let __v_82: G = __r_arr[19]; let __v_83: G = __r_arr[20]; let __v_84: G = __r_arr[21]; let __v_85: G = __r_arr[22]; let __v_86: G = __r_arr[23]; let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, &__args[..])?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = __r_arr[3]; let __v_91: G = __r_arr[4]; let __v_92: G = __r_arr[5]; let __v_93: G = __r_arr[6]; let __v_94: G = __r_arr[7]; let __v_95: G = __r_arr[8]; let __v_96: G = __r_arr[9]; let __v_97: G = __r_arr[10]; let __v_98: G = __r_arr[11]; let __v_99: G = __r_arr[12]; let __v_100: G = __r_arr[13]; let __v_101: G = __r_arr[14]; let __v_102: G = __r_arr[15]; let __v_103: G = __r_arr[16]; let __v_104: G = __r_arr[17]; let __v_105: G = __r_arr[18]; let __v_106: G = __r_arr[19]; let __v_107: G = __r_arr[20]; let __v_108: G = __r_arr[21]; let __v_109: G = __r_arr[22]; let __v_110: G = __r_arr[23]; let __v_111: G = __v_25 * __v_64; let __v_112: G = __v_27 * __v_65; let __v_113: G = __v_29 * __v_66; let __v_114: G = __v_31 * __v_67; let __v_115: G = __v_33 * __v_68; let __v_116: G = __v_35 * __v_69; let __v_117: G = __v_37 * __v_70; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_115 + __v_118; let __v_120: G = __v_114 + __v_119; let __v_121: G = __v_113 + __v_120; let __v_122: G = __v_112 + __v_121; let __v_123: G = __v_111 + __v_122; let __v_124: G = __v_63 + __v_123; let __v_125: G = G::from_u64(16); if (__v_124 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_124.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_126: G = __v_25 * __v_88; let __v_127: G = __v_27 * __v_89; let __v_128: G = __v_29 * __v_90; let __v_129: G = __v_31 * __v_91; let __v_130: G = __v_33 * __v_92; let __v_131: G = __v_35 * __v_93; let __v_132: G = __v_37 * __v_94; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_130 + __v_133; let __v_135: G = __v_129 + __v_134; let __v_136: G = __v_128 + __v_135; let __v_137: G = __v_127 + __v_136; let __v_138: G = __v_126 + __v_137; let __v_139: G = __v_87 + __v_138; if (__v_139 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_140: G = __v_25 * __v_72; let __v_141: G = __v_27 * __v_73; let __v_142: G = __v_29 * __v_74; let __v_143: G = __v_31 * __v_75; let __v_144: G = __v_33 * __v_76; let __v_145: G = __v_35 * __v_77; let __v_146: G = __v_37 * __v_78; let __v_147: G = __v_145 + __v_146; let __v_148: G = __v_144 + __v_147; let __v_149: G = __v_143 + __v_148; let __v_150: G = __v_142 + __v_149; let __v_151: G = __v_141 + __v_150; let __v_152: G = __v_140 + __v_151; let __v_153: G = __v_71 + __v_152; let __v_154: G = __v_25 * __v_96; let __v_155: G = __v_27 * __v_97; let __v_156: G = __v_29 * __v_98; let __v_157: G = __v_31 * __v_99; let __v_158: G = __v_33 * __v_100; let __v_159: G = __v_35 * __v_101; let __v_160: G = __v_37 * __v_102; let __v_161: G = __v_159 + __v_160; let __v_162: G = __v_158 + __v_161; let __v_163: G = __v_157 + __v_162; let __v_164: G = __v_156 + __v_163; let __v_165: G = __v_155 + __v_164; let __v_166: G = __v_154 + __v_165; let __v_167: G = __v_95 + __v_166; if (__v_167 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_168: G = __v_25 * __v_80; let __v_169: G = __v_27 * __v_81; let __v_170: G = __v_29 * __v_82; let __v_171: G = __v_31 * __v_83; let __v_172: G = __v_33 * __v_84; let __v_173: G = __v_35 * __v_85; let __v_174: G = __v_37 * __v_86; let __v_175: G = __v_173 + __v_174; let __v_176: G = __v_172 + __v_175; let __v_177: G = __v_171 + __v_176; let __v_178: G = __v_170 + __v_177; let __v_179: G = __v_169 + __v_178; let __v_180: G = __v_168 + __v_179; let __v_181: G = __v_79 + __v_180; let __v_182: G = __v_25 * __v_104; let __v_183: G = __v_27 * __v_105; let __v_184: G = __v_29 * __v_106; let __v_185: G = __v_31 * __v_107; let __v_186: G = __v_33 * __v_108; let __v_187: G = __v_35 * __v_109; let __v_188: G = __v_37 * __v_110; let __v_189: G = __v_187 + __v_188; let __v_190: G = __v_186 + __v_189; let __v_191: G = __v_185 + __v_190; let __v_192: G = __v_184 + __v_191; let __v_193: G = __v_183 + __v_192; let __v_194: G = __v_182 + __v_193; let __v_195: G = __v_103 + __v_194; let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_196: G = G::from_u8(__gb[0]); let __v_197: G = G::from_u8(__gb[1]); let __v_198: G = G::from_u8(__gb[2]); let __v_199: G = G::from_u8(__gb[3]); let __v_200: G = G::from_u8(__gb[4]); let __v_201: G = G::from_u8(__gb[5]); let __v_202: G = G::from_u8(__gb[6]); let __v_203: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; 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_198; let __vj = __v_199; 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_200; let __vj = __v_201; 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_202; let __vj = __v_203; 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_204: G = __v_25 * __v_197; let __v_205: G = __v_27 * __v_198; let __v_206: G = __v_29 * __v_199; let __v_207: G = __v_31 * __v_200; let __v_208: G = __v_33 * __v_201; let __v_209: G = __v_35 * __v_202; let __v_210: G = __v_37 * __v_203; let __v_211: G = __v_209 + __v_210; let __v_212: G = __v_208 + __v_211; let __v_213: G = __v_207 + __v_212; let __v_214: G = __v_206 + __v_213; let __v_215: G = __v_205 + __v_214; let __v_216: G = __v_204 + __v_215; let __v_217: G = __v_196 + __v_216; if (__v_217 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_218: G = G::from_u64(1020); let __v_219: G = __v_203 - __v_218; let __v_220: G = __v_202 + __v_219; let __v_221: G = __v_201 + __v_220; let __v_222: G = __v_200 + __v_221; let __v_223: G = G::from_bool(__v_222 == G::ZERO); let __v_224: G = __v_198 + __v_199; let __v_225: G = __v_197 + __v_224; let __v_226: G = __v_196 + __v_225; let __v_227: G = G::from_bool(__v_226 == G::ZERO); let __v_228: G = __v_46 - __v_227; let __v_229: G = __v_223 * __v_228; let __v_230: G = __v_46 - __v_229; if (__v_230 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_195.as_canonical_u64().to_le_bytes(); let __v_231: G = G::from_u8(__gb[0]); let __v_232: G = G::from_u8(__gb[1]); let __v_233: G = G::from_u8(__gb[2]); let __v_234: G = G::from_u8(__gb[3]); let __v_235: G = G::from_u8(__gb[4]); let __v_236: G = G::from_u8(__gb[5]); let __v_237: G = G::from_u8(__gb[6]); let __v_238: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_231; let __vj = __v_232; 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_233; let __vj = __v_234; 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_235; let __vj = __v_236; 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_237; let __vj = __v_238; 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_239: G = __v_25 * __v_232; let __v_240: G = __v_27 * __v_233; let __v_241: G = __v_29 * __v_234; let __v_242: G = __v_31 * __v_235; let __v_243: G = __v_33 * __v_236; let __v_244: G = __v_35 * __v_237; let __v_245: G = __v_37 * __v_238; let __v_246: G = __v_244 + __v_245; let __v_247: G = __v_243 + __v_246; let __v_248: G = __v_242 + __v_247; let __v_249: G = __v_241 + __v_248; let __v_250: G = __v_240 + __v_249; let __v_251: G = __v_239 + __v_250; let __v_252: G = __v_231 + __v_251; if (__v_252 != __v_195) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_195.as_canonical_u64(), msg: None }); } let __v_253: G = __v_238 - __v_218; let __v_254: G = __v_237 + __v_253; let __v_255: G = __v_236 + __v_254; let __v_256: G = __v_235 + __v_255; let __v_257: G = G::from_bool(__v_256 == G::ZERO); let __v_258: G = __v_233 + __v_234; let __v_259: G = __v_232 + __v_258; let __v_260: G = __v_231 + __v_259; let __v_261: G = G::from_bool(__v_260 == G::ZERO); let __v_262: G = __v_46 - __v_261; let __v_263: G = __v_257 * __v_262; let __v_264: G = __v_46 - __v_263; if (__v_264 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, &__args[..])?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_265: G = __r_arr[0]; if (__v_265 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_265.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_266: G = __v_153 - __v_1; let __v_267: G = G::from_bool(__v_266 == G::ZERO); let __gb: [u8; 8] = __v_153.as_canonical_u64().to_le_bytes(); let __v_268: G = G::from_u8(__gb[0]); let __v_269: G = G::from_u8(__gb[1]); let __v_270: G = G::from_u8(__gb[2]); let __v_271: G = G::from_u8(__gb[3]); let __v_272: G = G::from_u8(__gb[4]); let __v_273: G = G::from_u8(__gb[5]); let __v_274: G = G::from_u8(__gb[6]); let __v_275: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; 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_270; let __vj = __v_271; 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_272; let __vj = __v_273; 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_274; let __vj = __v_275; 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_276: G = __v_25 * __v_269; let __v_277: G = __v_27 * __v_270; let __v_278: G = __v_29 * __v_271; let __v_279: G = __v_31 * __v_272; let __v_280: G = __v_33 * __v_273; let __v_281: G = __v_35 * __v_274; let __v_282: G = __v_37 * __v_275; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_280 + __v_283; let __v_285: G = __v_279 + __v_284; let __v_286: G = __v_278 + __v_285; let __v_287: G = __v_277 + __v_286; let __v_288: G = __v_276 + __v_287; let __v_289: G = __v_268 + __v_288; if (__v_289 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_289.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_290: G = __v_275 - __v_218; let __v_291: G = __v_274 + __v_290; let __v_292: G = __v_273 + __v_291; let __v_293: G = __v_272 + __v_292; let __v_294: G = G::from_bool(__v_293 == G::ZERO); let __v_295: G = __v_270 + __v_271; let __v_296: G = __v_269 + __v_295; let __v_297: G = __v_268 + __v_296; let __v_298: G = G::from_bool(__v_297 == G::ZERO); let __v_299: G = __v_46 - __v_298; let __v_300: G = __v_294 * __v_299; let __v_301: G = __v_46 - __v_300; if (__v_301 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_301.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_302: G = G::from_u8(__gb[0]); let __v_303: G = G::from_u8(__gb[1]); let __v_304: G = G::from_u8(__gb[2]); let __v_305: G = G::from_u8(__gb[3]); let __v_306: G = G::from_u8(__gb[4]); let __v_307: G = G::from_u8(__gb[5]); let __v_308: G = G::from_u8(__gb[6]); let __v_309: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; 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_304; let __vj = __v_305; 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_306; let __vj = __v_307; 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_308; let __vj = __v_309; 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_310: G = __v_25 * __v_303; let __v_311: G = __v_27 * __v_304; let __v_312: G = __v_29 * __v_305; let __v_313: G = __v_31 * __v_306; let __v_314: G = __v_33 * __v_307; let __v_315: G = __v_35 * __v_308; let __v_316: G = __v_37 * __v_309; let __v_317: G = __v_315 + __v_316; let __v_318: G = __v_314 + __v_317; let __v_319: G = __v_313 + __v_318; let __v_320: G = __v_312 + __v_319; let __v_321: G = __v_311 + __v_320; let __v_322: G = __v_310 + __v_321; let __v_323: G = __v_302 + __v_322; if (__v_323 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_323.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_324: G = __v_309 - __v_218; let __v_325: G = __v_308 + __v_324; let __v_326: G = __v_307 + __v_325; let __v_327: G = __v_306 + __v_326; let __v_328: G = G::from_bool(__v_327 == G::ZERO); let __v_329: G = __v_304 + __v_305; let __v_330: G = __v_303 + __v_329; let __v_331: G = __v_302 + __v_330; let __v_332: G = G::from_bool(__v_331 == G::ZERO); let __v_333: G = __v_46 - __v_332; let __v_334: G = __v_328 * __v_333; let __v_335: G = __v_46 - __v_334; if (__v_335 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, &__args[..])?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_336: G = __r_arr[0]; let __v_337: G = __v_46 - __v_336; let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_338: G = G::from_u8(__gb[0]); let __v_339: G = G::from_u8(__gb[1]); let __v_340: G = G::from_u8(__gb[2]); let __v_341: G = G::from_u8(__gb[3]); let __v_342: G = G::from_u8(__gb[4]); let __v_343: G = G::from_u8(__gb[5]); let __v_344: G = G::from_u8(__gb[6]); let __v_345: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_338; let __vj = __v_339; 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_340; let __vj = __v_341; 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_342; let __vj = __v_343; 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_344; let __vj = __v_345; 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_346: G = __v_25 * __v_339; let __v_347: G = __v_27 * __v_340; let __v_348: G = __v_29 * __v_341; let __v_349: G = __v_31 * __v_342; let __v_350: G = __v_33 * __v_343; let __v_351: G = __v_35 * __v_344; let __v_352: G = __v_37 * __v_345; let __v_353: G = __v_351 + __v_352; let __v_354: G = __v_350 + __v_353; let __v_355: G = __v_349 + __v_354; let __v_356: G = __v_348 + __v_355; let __v_357: G = __v_347 + __v_356; let __v_358: G = __v_346 + __v_357; let __v_359: G = __v_338 + __v_358; if (__v_359 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_360: G = __v_345 - __v_218; let __v_361: G = __v_344 + __v_360; let __v_362: G = __v_343 + __v_361; let __v_363: G = __v_342 + __v_362; let __v_364: G = G::from_bool(__v_363 == G::ZERO); let __v_365: G = __v_340 + __v_341; let __v_366: G = __v_339 + __v_365; let __v_367: G = __v_338 + __v_366; let __v_368: G = G::from_bool(__v_367 == G::ZERO); let __v_369: G = __v_46 - __v_368; let __v_370: G = __v_364 * __v_369; let __v_371: G = __v_46 - __v_370; if (__v_371 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_372: G = G::from_u8(__gb[0]); let __v_373: G = G::from_u8(__gb[1]); let __v_374: G = G::from_u8(__gb[2]); let __v_375: G = G::from_u8(__gb[3]); let __v_376: G = G::from_u8(__gb[4]); let __v_377: G = G::from_u8(__gb[5]); let __v_378: G = G::from_u8(__gb[6]); let __v_379: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_372; let __vj = __v_373; 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_374; let __vj = __v_375; 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_376; let __vj = __v_377; 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_378; let __vj = __v_379; 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_380: G = __v_25 * __v_373; let __v_381: G = __v_27 * __v_374; let __v_382: G = __v_29 * __v_375; let __v_383: G = __v_31 * __v_376; let __v_384: G = __v_33 * __v_377; let __v_385: G = __v_35 * __v_378; let __v_386: G = __v_37 * __v_379; let __v_387: G = __v_385 + __v_386; let __v_388: G = __v_384 + __v_387; let __v_389: G = __v_383 + __v_388; let __v_390: G = __v_382 + __v_389; let __v_391: G = __v_381 + __v_390; let __v_392: G = __v_380 + __v_391; let __v_393: G = __v_372 + __v_392; if (__v_393 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_393.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_394: G = __v_379 - __v_218; let __v_395: G = __v_378 + __v_394; let __v_396: G = __v_377 + __v_395; let __v_397: G = __v_376 + __v_396; let __v_398: G = G::from_bool(__v_397 == G::ZERO); let __v_399: G = __v_374 + __v_375; let __v_400: G = __v_373 + __v_399; let __v_401: G = __v_372 + __v_400; let __v_402: G = G::from_bool(__v_401 == G::ZERO); let __v_403: G = __v_46 - __v_402; let __v_404: G = __v_398 * __v_403; let __v_405: G = __v_46 - __v_404; if (__v_405 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_378, __v_379]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, &__args[..])?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_406: G = __r_arr[0]; let __v_407: G = __v_267 * __v_406; let __v_408: G = __v_337 + __v_407; if (__v_408 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_24, __v_153, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, &__args[..])?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_409: G = __r_arr[0]; let __ret: [G; OUT_228] = [__v_409]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_229: usize = 46; const IN_229: usize = 46; const OUT_229: usize = 2; -fn aiur_fn_229(inp: [G; IN_229], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { let __v_46: G = G::from_u64(0); if (__v_1 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } if (__v_2 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_47: G = G::from_u64(1); if (__v_3 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None }); } match __v_12.as_canonical_u64() { _ => { match __v_17.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_bool((__v_48 == G::ZERO)); let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; if (__v_51 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; if (__v_52 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; if (__v_53 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, (&__args[..]))?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { (*(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203])) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = (__v_56 - __v_57); let __v_59: G = G::from_bool((__v_58 == G::ZERO)); if (__v_59 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = (__v_62 - __v_63); let __v_65: G = G::from_bool((__v_64 == G::ZERO)); if (__v_65 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_12, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = G::from_u64(1); if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_13, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, (&__args[..]))?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { (*(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218])) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; if (__v_68 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; if (__v_69 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, (&__args[..]))?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { (*(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222])) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, (&__args[..]))?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { (*(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223])) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; if (__v_71 != __v_72) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: None }); } let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = { let __values: [G; 3] = [__v_73, __v_73, __v_73]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_74]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_73: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_16, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(214, (&__args[..]))?) { [G::ZERO; OUT_214] } else { let (__hash, __hit) = record.function_queries[214].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[214].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { (*(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214])) }; __ret }, _ => { aiur_fn_214::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = G::from_u64(0); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, (&__args[..]))?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { (*(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202])) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_60, __v_61, __v_22, __v_21, __v_39, __v_40, __v_37, __v_38, __v_36, __v_79, __v_80, __v_81, __v_42, __v_43, __v_44, __v_45, __v_74, __v_75, __v_76, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, (&__args[..]))?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { (*(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200])) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __v_86: G = (__v_85 - __v_84); 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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = (__v_90 + __v_91); if (__v_89 != __v_92) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, (&__args[..]))?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { (*(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252])) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = (__v_93 - __v_84); let __v_95: G = G::from_bool((__v_94 == G::ZERO)); if (__v_95 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; if (__v_96 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __v_97: G = { let __values: [G; 3] = [__v_88, __v_88, __v_88]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_37.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_97]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_38, __v_97]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; break '__mc_1 [__v_98]; }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }; let __v_98: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_36, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_40, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_39, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_78, __v_101]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_102: G = __r_arr[0]; let __v_103: G = G::from_u64(1); let __v_104: G = { let __values: [G; 3] = [__v_103, __v_103, __v_103]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_102, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; let __v_108: G = __r_arr[3]; let __v_109: G = __r_arr[4]; let __v_110: G = __r_arr[5]; let __v_111: G = __r_arr[6]; let __v_112: G = __r_arr[7]; let __v_113: G = __r_arr[8]; let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = __r_arr[12]; let __v_118: G = __r_arr[13]; let __v_119: G = __r_arr[14]; let __v_120: G = __r_arr[15]; let __v_121: G = __r_arr[16]; let __v_122: G = __r_arr[17]; let __v_123: G = G::from_u64(256); let __v_124: G = (__v_123 * __v_106); let __v_125: G = G::from_u64(65536); let __v_126: G = (__v_125 * __v_107); let __v_127: G = G::from_u64(16777216); let __v_128: G = (__v_127 * __v_108); let __v_129: G = G::from_u64(4294967296); let __v_130: G = (__v_129 * __v_109); let __v_131: G = G::from_u64(1099511627776); let __v_132: G = (__v_131 * __v_110); let __v_133: G = G::from_u64(281474976710656); let __v_134: G = (__v_133 * __v_111); let __v_135: G = G::from_u64(72057594037927936); let __v_136: G = (__v_135 * __v_112); let __v_137: G = (__v_134 + __v_136); let __v_138: G = (__v_132 + __v_137); let __v_139: G = (__v_130 + __v_138); let __v_140: G = (__v_128 + __v_139); let __v_141: G = (__v_126 + __v_140); let __v_142: G = (__v_124 + __v_141); let __v_143: G = (__v_105 + __v_142); let __v_144: G = (__v_123 * __v_114); let __v_145: G = (__v_125 * __v_115); let __v_146: G = (__v_127 * __v_116); let __v_147: G = (__v_129 * __v_117); let __v_148: G = (__v_131 * __v_118); let __v_149: G = (__v_133 * __v_119); let __v_150: G = (__v_135 * __v_120); let __v_151: G = (__v_149 + __v_150); let __v_152: G = (__v_148 + __v_151); let __v_153: G = (__v_147 + __v_152); let __v_154: G = (__v_146 + __v_153); let __v_155: G = (__v_145 + __v_154); let __v_156: G = (__v_144 + __v_155); let __v_157: G = (__v_113 + __v_156); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_121, __v_23, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, (&__args[..]))?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { (*(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137])) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_27, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_159, __v_160]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_161: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_161, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_162, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; let __v_165: G = (__v_84 + __v_0); let __v_166: G = G::from_u64(33); let __v_167: G = { let __a_val = __v_165.as_canonical_u64(); let __b_val = __v_166.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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; if (__v_167 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_163, __v_164, __v_4, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_25, __v_168, __v_18, __v_19, __v_20, __v_73, __v_37, __v_38, __v_61, __v_22, __v_83, __v_0, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, (&__args[..]))?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { (*(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162])) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_169: G = __r_arr[0]; if (__v_169 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_25, __v_26, __v_170, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_171: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_163, __v_164, __v_171, __v_143, __v_157, __v_39, __v_40, __v_36, __v_37, __v_38, __v_18, __v_19, __v_20, __v_73, __v_61, __v_22, __v_76, __v_77, __v_83, __v_0, __v_165, __v_158, __v_23, __v_27, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, (&__args[..]))?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { (*(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157])) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_173: G = __r_arr[0]; if (__v_173 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, (&__args[..]))?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { (*(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219])) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_229] = [__v_174, __v_175]; record.function_queries[229].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } +fn aiur_fn_229(inp: [G; IN_229], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { let __v_46: G = G::from_u64(0); if (__v_1 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } if (__v_2 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_47: G = G::from_u64(1); if (__v_3 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None }); } match __v_12.as_canonical_u64() { _ => { match __v_17.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_bool(__v_48 == G::ZERO); let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; if (__v_51 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; if (__v_52 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; if (__v_53 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, &__args[..])?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __v_56 - __v_57; let __v_59: G = G::from_bool(__v_58 == G::ZERO); if (__v_59 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __v_62 - __v_63; let __v_65: G = G::from_bool(__v_64 == G::ZERO); if (__v_65 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_12, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = G::from_u64(1); if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_13, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, &__args[..])?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; if (__v_68 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; if (__v_69 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, &__args[..])?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, &__args[..])?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; if (__v_71 != __v_72) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: None }); } let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = { let __values: [G; 3] = [__v_73, __v_73, __v_73]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_74]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_73: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_16, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(214, &__args[..])?) { [G::ZERO; OUT_214] } else { let (__hash, __hit) = record.function_queries[214].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[214].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => { aiur_fn_214::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = G::from_u64(0); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, &__args[..])?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_60, __v_61, __v_22, __v_21, __v_39, __v_40, __v_37, __v_38, __v_36, __v_79, __v_80, __v_81, __v_42, __v_43, __v_44, __v_45, __v_74, __v_75, __v_76, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, &__args[..])?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __v_86: G = __v_85 - __v_84; 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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __v_90 + __v_91; if (__v_89 != __v_92) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, &__args[..])?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __v_93 - __v_84; let __v_95: G = G::from_bool(__v_94 == G::ZERO); if (__v_95 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; if (__v_96 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __v_97: G = { let __values: [G; 3] = [__v_88, __v_88, __v_88]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_37.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_97]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_38, __v_97]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; break '__mc_1 [__v_98]; }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }; let __v_98: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_36, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_40, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_39, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_78, __v_101]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_102: G = __r_arr[0]; let __v_103: G = G::from_u64(1); let __v_104: G = { let __values: [G; 3] = [__v_103, __v_103, __v_103]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_102, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; let __v_108: G = __r_arr[3]; let __v_109: G = __r_arr[4]; let __v_110: G = __r_arr[5]; let __v_111: G = __r_arr[6]; let __v_112: G = __r_arr[7]; let __v_113: G = __r_arr[8]; let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = __r_arr[12]; let __v_118: G = __r_arr[13]; let __v_119: G = __r_arr[14]; let __v_120: G = __r_arr[15]; let __v_121: G = __r_arr[16]; let __v_122: G = __r_arr[17]; let __v_123: G = G::from_u64(256); let __v_124: G = __v_123 * __v_106; let __v_125: G = G::from_u64(65536); let __v_126: G = __v_125 * __v_107; let __v_127: G = G::from_u64(16777216); let __v_128: G = __v_127 * __v_108; let __v_129: G = G::from_u64(4294967296); let __v_130: G = __v_129 * __v_109; let __v_131: G = G::from_u64(1099511627776); let __v_132: G = __v_131 * __v_110; let __v_133: G = G::from_u64(281474976710656); let __v_134: G = __v_133 * __v_111; let __v_135: G = G::from_u64(72057594037927936); let __v_136: G = __v_135 * __v_112; let __v_137: G = __v_134 + __v_136; let __v_138: G = __v_132 + __v_137; let __v_139: G = __v_130 + __v_138; let __v_140: G = __v_128 + __v_139; let __v_141: G = __v_126 + __v_140; let __v_142: G = __v_124 + __v_141; let __v_143: G = __v_105 + __v_142; let __v_144: G = __v_123 * __v_114; let __v_145: G = __v_125 * __v_115; let __v_146: G = __v_127 * __v_116; let __v_147: G = __v_129 * __v_117; let __v_148: G = __v_131 * __v_118; let __v_149: G = __v_133 * __v_119; let __v_150: G = __v_135 * __v_120; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_148 + __v_151; let __v_153: G = __v_147 + __v_152; let __v_154: G = __v_146 + __v_153; let __v_155: G = __v_145 + __v_154; let __v_156: G = __v_144 + __v_155; let __v_157: G = __v_113 + __v_156; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_121, __v_23, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, &__args[..])?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_27, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_159, __v_160]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_161: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_161, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_162, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; let __v_165: G = __v_84 + __v_0; let __v_166: G = G::from_u64(33); let __v_167: G = { let __a_val = __v_165.as_canonical_u64(); let __b_val = __v_166.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 __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; if (__v_167 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_163, __v_164, __v_4, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_25, __v_168, __v_18, __v_19, __v_20, __v_73, __v_37, __v_38, __v_61, __v_22, __v_83, __v_0, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, &__args[..])?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_169: G = __r_arr[0]; if (__v_169 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_25, __v_26, __v_170, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_171: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_163, __v_164, __v_171, __v_143, __v_157, __v_39, __v_40, __v_36, __v_37, __v_38, __v_18, __v_19, __v_20, __v_73, __v_61, __v_22, __v_76, __v_77, __v_83, __v_0, __v_165, __v_158, __v_23, __v_27, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, &__args[..])?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_173: G = __r_arr[0]; if (__v_173 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, &__args[..])?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_229] = [__v_174, __v_175]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } const INPUT_SIZE_230: usize = 22; const IN_230: usize = 22; const OUT_230: usize = 2; -fn aiur_fn_230(inp: [G; IN_230], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; let __v_26: G = __loaded[4]; let __v_27: G = __loaded[5]; match __v_22.as_canonical_u64() { 1u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; let __v_54: G = G::from_u64(1); if (__v_28 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_29 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_30 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_31 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_32 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_33 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_34 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_35 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_36 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_37 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_38 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_39 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_40 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_41 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_42 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_43 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_44 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_45 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_46 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_47 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_48 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_49 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_50 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_51 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_52 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_53 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_230] = [__v_20, __v_21]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1, __v_2, __v_3, __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_14, __v_29, __v_30, __v_31, __v_32, __v_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_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = (__v_14 + __v_56); let __v_58: G = (__v_20 + __v_54); let __v_59: G = (__v_21 + __v_55); let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_27, __v_53, __v_57, __v_15, __v_16, __v_17, __v_18, __v_19, __v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, (&__args[..]))?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { (*(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230])) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_230] = [__v_60, __v_61]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }) } +fn aiur_fn_230(inp: [G; IN_230], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; let __v_26: G = __loaded[4]; let __v_27: G = __loaded[5]; match __v_22.as_canonical_u64() { 1u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; let __v_54: G = G::from_u64(1); if (__v_28 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_29 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_30 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_31 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_32 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_33 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_34 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_35 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_36 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_37 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_38 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_39 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_40 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_41 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_42 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_43 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_44 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_45 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_46 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_47 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_48 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_49 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_50 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_51 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_52 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_53 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_230] = [__v_20, __v_21]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1, __v_2, __v_3, __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_14, __v_29, __v_30, __v_31, __v_32, __v_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_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = __v_14 + __v_56; let __v_58: G = __v_20 + __v_54; let __v_59: G = __v_21 + __v_55; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_27, __v_53, __v_57, __v_15, __v_16, __v_17, __v_18, __v_19, __v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, &__args[..])?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_230] = [__v_60, __v_61]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }) } const INPUT_SIZE_231: usize = 1; const IN_231: usize = 1; const OUT_231: usize = 1; -fn aiur_fn_231(inp: [G; IN_231], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, (&__args[..]))?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { (*(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231])) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_231(inp: [G; IN_231], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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 = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, &__args[..])?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_232: usize = 15; const IN_232: usize = 15; const OUT_232: usize = 1; -fn aiur_fn_232(inp: [G; IN_232], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_12.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(224, (&__args[..]))?) { [G::ZERO; OUT_224] } else { let (__hash, __hit) = record.function_queries[224].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[224].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { (*(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224])) }; __ret }, _ => { aiur_fn_224::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, (&__args[..]))?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { (*(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228])) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_23]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_22: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_22, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, (&__args[..]))?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { (*(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213])) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(0); let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, (&__args[..]))?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { (*(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220])) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_28, __v_27, __v_23, __v_24, __v_25, __v_26, __v_29, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, (&__args[..]))?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { (*(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230])) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_bool((__v_31 == G::ZERO)); let __v_34: G = G::from_bool((__v_32 == G::ZERO)); let __v_35: G = (__v_33 * __v_34); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, (&__args[..]))?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { (*(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231])) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_232] = [__v_37]; record.function_queries[232].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_232(inp: [G; IN_232], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_12.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(224, &__args[..])?) { [G::ZERO; OUT_224] } else { let (__hash, __hit) = record.function_queries[224].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[224].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => { aiur_fn_224::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, &__args[..])?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_23]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_22: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_22, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, &__args[..])?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; 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 = G::from_u64(0); let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, &__args[..])?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_28, __v_27, __v_23, __v_24, __v_25, __v_26, __v_29, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, &__args[..])?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_bool(__v_31 == G::ZERO); let __v_34: G = G::from_bool(__v_32 == G::ZERO); let __v_35: G = __v_33 * __v_34; let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, &__args[..])?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_232] = [__v_37]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_233: usize = 15; const IN_233: usize = 15; const OUT_233: usize = 1; -fn aiur_fn_233(inp: [G; IN_233], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_16, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = (__v_12 + __v_13); 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_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17, __v_21, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, (&__args[..]))?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { (*(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232])) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_28, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, (&__args[..]))?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { (*(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217])) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; 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 }); } let __ret: [G; OUT_233] = [__v_30]; record.function_queries[233].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_233(inp: [G; IN_233], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_16, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __v_12 + __v_13; 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_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17, __v_21, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, &__args[..])?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_28, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, &__args[..])?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; 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 }); } let __ret: [G; OUT_233] = [__v_30]; record.function_queries[233].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_234: usize = 1; const IN_234: usize = 1; const OUT_234: usize = 2; -fn aiur_fn_234(inp: [G; IN_234], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, (&__args[..]))?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { (*(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235])) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_234] = [__v_3, __v_4]; record.function_queries[234].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_234(inp: [G; IN_234], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, &__args[..])?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_234] = [__v_3, __v_4]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_235: usize = 2; const IN_235: usize = 2; const OUT_235: usize = 2; -fn aiur_fn_235(inp: [G; IN_235], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_3, __v_0]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, (&__args[..]))?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { (*(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237])) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; 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_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, (&__args[..]))?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { (*(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235])) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_11, __v_9]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_235(inp: [G; IN_235], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_3, __v_0]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, &__args[..])?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; 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_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, &__args[..])?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_11, __v_9]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, (&__args[..]))?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { (*(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237])) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_236] = [__v_3, __v_4]; record.function_queries[236].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_236(inp: [G; IN_236], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, &__args[..])?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_236] = [__v_3, __v_4]; record.function_queries[236].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_3, __v_0]; record.function_queries[237].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, (&__args[..]))?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { (*(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25])) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, (&__args[..]))?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { (*(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237])) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_16, __v_14]; record.function_queries[237].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_237(inp: [G; IN_237], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_3, __v_0]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, &__args[..])?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, &__args[..])?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_16, __v_14]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_238: usize = 16; const IN_238: usize = 16; const OUT_238: usize = 0; -fn aiur_fn_238(inp: [G; IN_238], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __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 = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_16, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_17: G = __io_pair.0; let __v_18: G = __io_pair.1; let __v_19: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_19, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_20: G = __io_pair.0; let __v_21: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_19, __v_20, __v_21]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(103); let __v_24: G = G::from_u64(230); let __v_25: G = G::from_u64(9); let __v_26: G = G::from_u64(106); let __v_27: G = G::from_u64(133); let __v_28: G = G::from_u64(174); let __v_29: G = G::from_u64(187); let __v_30: G = G::from_u64(114); let __v_31: G = G::from_u64(243); let __v_32: G = G::from_u64(110); let __v_33: G = G::from_u64(60); let __v_34: G = G::from_u64(58); let __v_35: G = G::from_u64(245); let __v_36: G = G::from_u64(79); let __v_37: G = G::from_u64(165); let __v_38: G = G::from_u64(127); let __v_39: G = G::from_u64(82); let __v_40: G = G::from_u64(14); let __v_41: G = G::from_u64(81); let __v_42: G = G::from_u64(140); let __v_43: G = G::from_u64(104); let __v_44: G = G::from_u64(5); let __v_45: G = G::from_u64(155); let __v_46: G = G::from_u64(171); let __v_47: G = G::from_u64(217); let __v_48: G = G::from_u64(131); let __v_49: G = G::from_u64(31); let __v_50: G = G::from_u64(25); let __v_51: G = G::from_u64(205); let __v_52: G = G::from_u64(224); let __v_53: G = G::from_u64(91); let __v_54: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 8] = [__v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 32] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_23, __v_29, __v_30, __v_31, __v_32, __v_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]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 34] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_22, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = __r_arr[3]; let __v_63: G = __r_arr[4]; let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; let __v_67: G = __r_arr[8]; let __v_68: G = __r_arr[9]; let __v_69: G = __r_arr[10]; let __v_70: G = __r_arr[11]; let __v_71: G = __r_arr[12]; let __v_72: G = __r_arr[13]; let __v_73: G = __r_arr[14]; let __v_74: G = __r_arr[15]; let __v_75: G = __r_arr[16]; let __v_76: G = __r_arr[17]; let __v_77: G = __r_arr[18]; let __v_78: G = __r_arr[19]; let __v_79: G = __r_arr[20]; let __v_80: G = __r_arr[21]; let __v_81: G = __r_arr[22]; let __v_82: G = __r_arr[23]; let __v_83: G = __r_arr[24]; let __v_84: G = __r_arr[25]; let __v_85: G = __r_arr[26]; let __v_86: G = __r_arr[27]; let __v_87: G = __r_arr[28]; let __v_88: G = __r_arr[29]; let __v_89: G = __r_arr[30]; let __v_90: G = __r_arr[31]; let __v_91: G = G::from_u64(256); let __v_92: G = (__v_91 * __v_60); let __v_93: G = G::from_u64(65536); let __v_94: G = (__v_93 * __v_61); let __v_95: G = G::from_u64(16777216); let __v_96: G = (__v_95 * __v_62); let __v_97: G = (__v_94 + __v_96); let __v_98: G = (__v_92 + __v_97); let __v_99: G = (__v_59 + __v_98); let __v_100: G = (__v_91 * __v_64); let __v_101: G = (__v_93 * __v_65); let __v_102: G = (__v_95 * __v_66); let __v_103: G = (__v_101 + __v_102); let __v_104: G = (__v_100 + __v_103); let __v_105: G = (__v_63 + __v_104); let __v_106: G = (__v_91 * __v_68); let __v_107: G = (__v_93 * __v_69); let __v_108: G = (__v_95 * __v_70); let __v_109: G = (__v_107 + __v_108); let __v_110: G = (__v_106 + __v_109); let __v_111: G = (__v_67 + __v_110); let __v_112: G = (__v_91 * __v_72); let __v_113: G = (__v_93 * __v_73); let __v_114: G = (__v_95 * __v_74); let __v_115: G = (__v_113 + __v_114); let __v_116: G = (__v_112 + __v_115); let __v_117: G = (__v_71 + __v_116); let __v_118: G = (__v_91 * __v_76); let __v_119: G = (__v_93 * __v_77); let __v_120: G = (__v_95 * __v_78); let __v_121: G = (__v_119 + __v_120); let __v_122: G = (__v_118 + __v_121); let __v_123: G = (__v_75 + __v_122); let __v_124: G = (__v_91 * __v_80); let __v_125: G = (__v_93 * __v_81); let __v_126: G = (__v_95 * __v_82); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_124 + __v_127); let __v_129: G = (__v_79 + __v_128); let __v_130: G = (__v_91 * __v_84); let __v_131: G = (__v_93 * __v_85); let __v_132: G = (__v_95 * __v_86); let __v_133: G = (__v_131 + __v_132); let __v_134: G = (__v_130 + __v_133); let __v_135: G = (__v_83 + __v_134); let __v_136: G = (__v_91 * __v_88); let __v_137: G = (__v_93 * __v_89); let __v_138: G = (__v_95 * __v_90); let __v_139: G = (__v_137 + __v_138); let __v_140: G = (__v_136 + __v_139); let __v_141: G = (__v_87 + __v_140); if (__v_99 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } if (__v_105 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } if (__v_111 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } if (__v_117 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } if (__v_123 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } if (__v_129 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } if (__v_135 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_135.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } if (__v_141 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_151]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __v_154: G = __r_arr[2]; let __v_155: G = __r_arr[3]; let __v_156: G = __r_arr[4]; let __v_157: G = __r_arr[5]; let __v_158: G = __r_arr[6]; let __v_159: G = __r_arr[7]; let __v_160: G = __r_arr[8]; let __v_161: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __v_163: G = __r_arr[1]; let __v_164: G = __r_arr[2]; let __v_165: G = __r_arr[3]; let __v_166: G = __r_arr[4]; let __v_167: G = __r_arr[5]; let __v_168: G = __r_arr[6]; let __v_169: G = __r_arr[7]; let __v_170: G = __r_arr[8]; let __v_171: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_171]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __v_184: G = __r_arr[2]; let __v_185: G = __r_arr[3]; let __v_186: G = __r_arr[4]; let __v_187: G = __r_arr[5]; let __v_188: G = __r_arr[6]; let __v_189: G = __r_arr[7]; let __v_190: G = __r_arr[8]; let __v_191: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_191]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_192: G = __r_arr[0]; let __v_193: G = __r_arr[1]; let __v_194: G = __r_arr[2]; let __v_195: G = __r_arr[3]; let __v_196: G = __r_arr[4]; let __v_197: G = __r_arr[5]; let __v_198: G = __r_arr[6]; let __v_199: G = __r_arr[7]; let __v_200: G = __r_arr[8]; let __v_201: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_201]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_202: G = __r_arr[0]; let __v_203: G = __r_arr[1]; let __v_204: G = __r_arr[2]; let __v_205: G = __r_arr[3]; let __v_206: G = __r_arr[4]; let __v_207: G = __r_arr[5]; let __v_208: G = __r_arr[6]; let __v_209: G = __r_arr[7]; let __v_210: G = __r_arr[8]; let __v_211: G = __r_arr[9]; let __v_212: G = { let __values: [G; 10] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_213: G = { let __values: [G; 10] = [__v_16, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_212]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_214: G = { let __values: [G; 10] = [__v_16, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_213]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_215: G = { let __values: [G; 10] = [__v_16, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_214]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_216: G = { let __values: [G; 10] = [__v_16, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_215]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_217: G = { let __values: [G; 10] = [__v_16, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_216]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_218: G = { let __values: [G; 10] = [__v_16, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_217]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_219: G = { let __values: [G; 10] = [__v_16, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_218]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_211]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __v_221: G = __r_arr[1]; let __v_222: G = __r_arr[2]; let __v_223: G = __r_arr[3]; let __v_224: G = __r_arr[4]; let __v_225: G = __r_arr[5]; let __v_226: G = __r_arr[6]; let __v_227: G = __r_arr[7]; let __v_228: G = __r_arr[8]; let __v_229: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_229, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_230: G = __r_arr[0]; let __v_231: G = __r_arr[1]; let __v_232: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_232]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, (&__args[..]))?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { (*(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101])) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_233: G = __r_arr[0]; let __v_234: G = __r_arr[1]; let __v_235: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_235, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, (&__args[..]))?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { (*(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102])) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_236: G = __r_arr[0]; let __v_237: G = __r_arr[1]; let __v_238: G = { let __values: [G; 10] = [__v_16, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_231]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_219, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_239: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_237.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_240: G = __loaded[0]; let __v_241: G = __loaded[1]; let __v_242: G = __loaded[2]; if (__v_240 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_241 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_242 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_243: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_243, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_244: G = __io_pair.0; let __v_245: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_243, __v_244, __v_245]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_246: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_246, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_247: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_247]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_248: G = __r_arr[0]; let __v_249: G = __r_arr[1]; let __v_250: G = __r_arr[2]; let __v_251: G = __r_arr[3]; let __v_252: G = __r_arr[4]; let __v_253: G = __r_arr[5]; let __v_254: G = __r_arr[6]; let __v_255: G = __r_arr[7]; let __v_256: G = __r_arr[8]; let __v_257: G = __r_arr[9]; let __v_258: G = __r_arr[10]; let __v_259: G = __r_arr[11]; let __v_260: G = __r_arr[12]; let __v_261: G = __r_arr[13]; let __v_262: G = __r_arr[14]; let __v_263: G = __r_arr[15]; let __v_264: G = __r_arr[16]; let __v_265: G = __r_arr[17]; let __v_266: G = __r_arr[18]; let __v_267: G = __r_arr[19]; let __v_268: G = __r_arr[20]; let __v_269: G = __r_arr[21]; let __v_270: G = __r_arr[22]; let __v_271: G = __r_arr[23]; let __v_272: G = __r_arr[24]; let __v_273: G = __r_arr[25]; let __v_274: G = __r_arr[26]; let __v_275: G = __r_arr[27]; let __v_276: G = __r_arr[28]; let __v_277: G = __r_arr[29]; let __v_278: G = __r_arr[30]; let __v_279: G = __r_arr[31]; let __v_280: G = (__v_91 * __v_249); let __v_281: G = (__v_93 * __v_250); let __v_282: G = (__v_95 * __v_251); let __v_283: G = (__v_281 + __v_282); let __v_284: G = (__v_280 + __v_283); let __v_285: G = (__v_248 + __v_284); let __v_286: G = (__v_91 * __v_253); let __v_287: G = (__v_93 * __v_254); let __v_288: G = (__v_95 * __v_255); let __v_289: G = (__v_287 + __v_288); let __v_290: G = (__v_286 + __v_289); let __v_291: G = (__v_252 + __v_290); let __v_292: G = (__v_91 * __v_257); let __v_293: G = (__v_93 * __v_258); let __v_294: G = (__v_95 * __v_259); let __v_295: G = (__v_293 + __v_294); let __v_296: G = (__v_292 + __v_295); let __v_297: G = (__v_256 + __v_296); let __v_298: G = (__v_91 * __v_261); let __v_299: G = (__v_93 * __v_262); let __v_300: G = (__v_95 * __v_263); let __v_301: G = (__v_299 + __v_300); let __v_302: G = (__v_298 + __v_301); let __v_303: G = (__v_260 + __v_302); let __v_304: G = (__v_91 * __v_265); let __v_305: G = (__v_93 * __v_266); let __v_306: G = (__v_95 * __v_267); let __v_307: G = (__v_305 + __v_306); let __v_308: G = (__v_304 + __v_307); let __v_309: G = (__v_264 + __v_308); let __v_310: G = (__v_91 * __v_269); let __v_311: G = (__v_93 * __v_270); let __v_312: G = (__v_95 * __v_271); let __v_313: G = (__v_311 + __v_312); let __v_314: G = (__v_310 + __v_313); let __v_315: G = (__v_268 + __v_314); let __v_316: G = (__v_91 * __v_273); let __v_317: G = (__v_93 * __v_274); let __v_318: G = (__v_95 * __v_275); let __v_319: G = (__v_317 + __v_318); let __v_320: G = (__v_316 + __v_319); let __v_321: G = (__v_272 + __v_320); let __v_322: G = (__v_91 * __v_277); let __v_323: G = (__v_93 * __v_278); let __v_324: G = (__v_95 * __v_279); let __v_325: G = (__v_323 + __v_324); let __v_326: G = (__v_322 + __v_325); let __v_327: G = (__v_276 + __v_326); if (__v_285 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_291 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_291.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } if (__v_297 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_297.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } if (__v_303 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_303.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } if (__v_309 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_315 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_315.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } if (__v_321 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_321.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } if (__v_327 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_327.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_246]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_328: G = __r_arr[0]; let __v_329: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_329, __v_328]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, (&__args[..]))?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { (*(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235])) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_330: G = __r_arr[0]; let __v_331: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_331.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_332: G = __loaded[0]; let __v_333: G = __loaded[1]; let __v_334: G = __loaded[2]; if (__v_332 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_332.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_333 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_333.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_334 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_334.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_335: G = __r_arr[0]; let __v_336: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_336, __v_335]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_337: G = __r_arr[0]; let __v_338: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_338]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_339: G = __r_arr[0]; let __v_340: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_340, __v_339]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_341: G = __r_arr[0]; let __v_342: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_342]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_343: G = __r_arr[0]; let __v_344: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_344, __v_343]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_345: G = __r_arr[0]; let __v_346: G = __r_arr[1]; let __v_347: G = (__v_17 + __v_18); if (__v_346 != __v_347) { return Err(ExecError::AssertEqMismatch { lhs: __v_346.as_canonical_u64(), rhs: __v_347.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_142, __v_152, __v_162, __v_172, __v_182, __v_192, __v_202, __v_239, __v_230, __v_233, __v_234, __v_236, __v_337, __v_341, __v_345]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, (&__args[..]))?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { (*(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232])) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_348: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_348, __v_330]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, (&__args[..]))?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { (*(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217])) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_349: G = __r_arr[0]; if (__v_349 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_349.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_19 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_238] = []; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_238(inp: [G; IN_238], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __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 = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_17: G = __io_pair.0; let __v_18: G = __io_pair.1; let __v_19: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_19, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_20: G = __io_pair.0; let __v_21: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_19, __v_20, __v_21]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(103); let __v_24: G = G::from_u64(230); let __v_25: G = G::from_u64(9); let __v_26: G = G::from_u64(106); let __v_27: G = G::from_u64(133); let __v_28: G = G::from_u64(174); let __v_29: G = G::from_u64(187); let __v_30: G = G::from_u64(114); let __v_31: G = G::from_u64(243); let __v_32: G = G::from_u64(110); let __v_33: G = G::from_u64(60); let __v_34: G = G::from_u64(58); let __v_35: G = G::from_u64(245); let __v_36: G = G::from_u64(79); let __v_37: G = G::from_u64(165); let __v_38: G = G::from_u64(127); let __v_39: G = G::from_u64(82); let __v_40: G = G::from_u64(14); let __v_41: G = G::from_u64(81); let __v_42: G = G::from_u64(140); let __v_43: G = G::from_u64(104); let __v_44: G = G::from_u64(5); let __v_45: G = G::from_u64(155); let __v_46: G = G::from_u64(171); let __v_47: G = G::from_u64(217); let __v_48: G = G::from_u64(131); let __v_49: G = G::from_u64(31); let __v_50: G = G::from_u64(25); let __v_51: G = G::from_u64(205); let __v_52: G = G::from_u64(224); let __v_53: G = G::from_u64(91); let __v_54: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 8] = [__v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 32] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_23, __v_29, __v_30, __v_31, __v_32, __v_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]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 34] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_22, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = __r_arr[3]; let __v_63: G = __r_arr[4]; let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; let __v_67: G = __r_arr[8]; let __v_68: G = __r_arr[9]; let __v_69: G = __r_arr[10]; let __v_70: G = __r_arr[11]; let __v_71: G = __r_arr[12]; let __v_72: G = __r_arr[13]; let __v_73: G = __r_arr[14]; let __v_74: G = __r_arr[15]; let __v_75: G = __r_arr[16]; let __v_76: G = __r_arr[17]; let __v_77: G = __r_arr[18]; let __v_78: G = __r_arr[19]; let __v_79: G = __r_arr[20]; let __v_80: G = __r_arr[21]; let __v_81: G = __r_arr[22]; let __v_82: G = __r_arr[23]; let __v_83: G = __r_arr[24]; let __v_84: G = __r_arr[25]; let __v_85: G = __r_arr[26]; let __v_86: G = __r_arr[27]; let __v_87: G = __r_arr[28]; let __v_88: G = __r_arr[29]; let __v_89: G = __r_arr[30]; let __v_90: G = __r_arr[31]; let __v_91: G = G::from_u64(256); let __v_92: G = __v_91 * __v_60; let __v_93: G = G::from_u64(65536); let __v_94: G = __v_93 * __v_61; let __v_95: G = G::from_u64(16777216); let __v_96: G = __v_95 * __v_62; let __v_97: G = __v_94 + __v_96; let __v_98: G = __v_92 + __v_97; let __v_99: G = __v_59 + __v_98; let __v_100: G = __v_91 * __v_64; let __v_101: G = __v_93 * __v_65; let __v_102: G = __v_95 * __v_66; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_100 + __v_103; let __v_105: G = __v_63 + __v_104; let __v_106: G = __v_91 * __v_68; let __v_107: G = __v_93 * __v_69; let __v_108: G = __v_95 * __v_70; let __v_109: G = __v_107 + __v_108; let __v_110: G = __v_106 + __v_109; let __v_111: G = __v_67 + __v_110; let __v_112: G = __v_91 * __v_72; let __v_113: G = __v_93 * __v_73; let __v_114: G = __v_95 * __v_74; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_112 + __v_115; let __v_117: G = __v_71 + __v_116; let __v_118: G = __v_91 * __v_76; let __v_119: G = __v_93 * __v_77; let __v_120: G = __v_95 * __v_78; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_118 + __v_121; let __v_123: G = __v_75 + __v_122; let __v_124: G = __v_91 * __v_80; let __v_125: G = __v_93 * __v_81; let __v_126: G = __v_95 * __v_82; let __v_127: G = __v_125 + __v_126; let __v_128: G = __v_124 + __v_127; let __v_129: G = __v_79 + __v_128; let __v_130: G = __v_91 * __v_84; let __v_131: G = __v_93 * __v_85; let __v_132: G = __v_95 * __v_86; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_130 + __v_133; let __v_135: G = __v_83 + __v_134; let __v_136: G = __v_91 * __v_88; let __v_137: G = __v_93 * __v_89; let __v_138: G = __v_95 * __v_90; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_136 + __v_139; let __v_141: G = __v_87 + __v_140; if (__v_99 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } if (__v_105 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } if (__v_111 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } if (__v_117 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } if (__v_123 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } if (__v_129 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } if (__v_135 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_135.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } if (__v_141 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_151]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __v_154: G = __r_arr[2]; let __v_155: G = __r_arr[3]; let __v_156: G = __r_arr[4]; let __v_157: G = __r_arr[5]; let __v_158: G = __r_arr[6]; let __v_159: G = __r_arr[7]; let __v_160: G = __r_arr[8]; let __v_161: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __v_163: G = __r_arr[1]; let __v_164: G = __r_arr[2]; let __v_165: G = __r_arr[3]; let __v_166: G = __r_arr[4]; let __v_167: G = __r_arr[5]; let __v_168: G = __r_arr[6]; let __v_169: G = __r_arr[7]; let __v_170: G = __r_arr[8]; let __v_171: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_171]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __v_184: G = __r_arr[2]; let __v_185: G = __r_arr[3]; let __v_186: G = __r_arr[4]; let __v_187: G = __r_arr[5]; let __v_188: G = __r_arr[6]; let __v_189: G = __r_arr[7]; let __v_190: G = __r_arr[8]; let __v_191: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_191]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_192: G = __r_arr[0]; let __v_193: G = __r_arr[1]; let __v_194: G = __r_arr[2]; let __v_195: G = __r_arr[3]; let __v_196: G = __r_arr[4]; let __v_197: G = __r_arr[5]; let __v_198: G = __r_arr[6]; let __v_199: G = __r_arr[7]; let __v_200: G = __r_arr[8]; let __v_201: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_201]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_202: G = __r_arr[0]; let __v_203: G = __r_arr[1]; let __v_204: G = __r_arr[2]; let __v_205: G = __r_arr[3]; let __v_206: G = __r_arr[4]; let __v_207: G = __r_arr[5]; let __v_208: G = __r_arr[6]; let __v_209: G = __r_arr[7]; let __v_210: G = __r_arr[8]; let __v_211: G = __r_arr[9]; let __v_212: G = { let __values: [G; 10] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_213: G = { let __values: [G; 10] = [__v_16, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_212]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_214: G = { let __values: [G; 10] = [__v_16, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_213]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_215: G = { let __values: [G; 10] = [__v_16, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_214]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_216: G = { let __values: [G; 10] = [__v_16, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_215]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_217: G = { let __values: [G; 10] = [__v_16, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_216]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_218: G = { let __values: [G; 10] = [__v_16, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_217]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_219: G = { let __values: [G; 10] = [__v_16, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_218]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_211]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __v_221: G = __r_arr[1]; let __v_222: G = __r_arr[2]; let __v_223: G = __r_arr[3]; let __v_224: G = __r_arr[4]; let __v_225: G = __r_arr[5]; let __v_226: G = __r_arr[6]; let __v_227: G = __r_arr[7]; let __v_228: G = __r_arr[8]; let __v_229: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_229, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_230: G = __r_arr[0]; let __v_231: G = __r_arr[1]; let __v_232: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_232]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, &__args[..])?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_233: G = __r_arr[0]; let __v_234: G = __r_arr[1]; let __v_235: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_235, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, &__args[..])?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_236: G = __r_arr[0]; let __v_237: G = __r_arr[1]; let __v_238: G = { let __values: [G; 10] = [__v_16, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_231]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_219, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, &__args[..])?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_239: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_237.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_240: G = __loaded[0]; let __v_241: G = __loaded[1]; let __v_242: G = __loaded[2]; if (__v_240 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_241 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_242 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_243: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_243, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_244: G = __io_pair.0; let __v_245: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_243, __v_244, __v_245]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_246: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_246, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_247: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_247]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_248: G = __r_arr[0]; let __v_249: G = __r_arr[1]; let __v_250: G = __r_arr[2]; let __v_251: G = __r_arr[3]; let __v_252: G = __r_arr[4]; let __v_253: G = __r_arr[5]; let __v_254: G = __r_arr[6]; let __v_255: G = __r_arr[7]; let __v_256: G = __r_arr[8]; let __v_257: G = __r_arr[9]; let __v_258: G = __r_arr[10]; let __v_259: G = __r_arr[11]; let __v_260: G = __r_arr[12]; let __v_261: G = __r_arr[13]; let __v_262: G = __r_arr[14]; let __v_263: G = __r_arr[15]; let __v_264: G = __r_arr[16]; let __v_265: G = __r_arr[17]; let __v_266: G = __r_arr[18]; let __v_267: G = __r_arr[19]; let __v_268: G = __r_arr[20]; let __v_269: G = __r_arr[21]; let __v_270: G = __r_arr[22]; let __v_271: G = __r_arr[23]; let __v_272: G = __r_arr[24]; let __v_273: G = __r_arr[25]; let __v_274: G = __r_arr[26]; let __v_275: G = __r_arr[27]; let __v_276: G = __r_arr[28]; let __v_277: G = __r_arr[29]; let __v_278: G = __r_arr[30]; let __v_279: G = __r_arr[31]; let __v_280: G = __v_91 * __v_249; let __v_281: G = __v_93 * __v_250; let __v_282: G = __v_95 * __v_251; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_280 + __v_283; let __v_285: G = __v_248 + __v_284; let __v_286: G = __v_91 * __v_253; let __v_287: G = __v_93 * __v_254; let __v_288: G = __v_95 * __v_255; let __v_289: G = __v_287 + __v_288; let __v_290: G = __v_286 + __v_289; let __v_291: G = __v_252 + __v_290; let __v_292: G = __v_91 * __v_257; let __v_293: G = __v_93 * __v_258; let __v_294: G = __v_95 * __v_259; let __v_295: G = __v_293 + __v_294; let __v_296: G = __v_292 + __v_295; let __v_297: G = __v_256 + __v_296; let __v_298: G = __v_91 * __v_261; let __v_299: G = __v_93 * __v_262; let __v_300: G = __v_95 * __v_263; let __v_301: G = __v_299 + __v_300; let __v_302: G = __v_298 + __v_301; let __v_303: G = __v_260 + __v_302; let __v_304: G = __v_91 * __v_265; let __v_305: G = __v_93 * __v_266; let __v_306: G = __v_95 * __v_267; let __v_307: G = __v_305 + __v_306; let __v_308: G = __v_304 + __v_307; let __v_309: G = __v_264 + __v_308; let __v_310: G = __v_91 * __v_269; let __v_311: G = __v_93 * __v_270; let __v_312: G = __v_95 * __v_271; let __v_313: G = __v_311 + __v_312; let __v_314: G = __v_310 + __v_313; let __v_315: G = __v_268 + __v_314; let __v_316: G = __v_91 * __v_273; let __v_317: G = __v_93 * __v_274; let __v_318: G = __v_95 * __v_275; let __v_319: G = __v_317 + __v_318; let __v_320: G = __v_316 + __v_319; let __v_321: G = __v_272 + __v_320; let __v_322: G = __v_91 * __v_277; let __v_323: G = __v_93 * __v_278; let __v_324: G = __v_95 * __v_279; let __v_325: G = __v_323 + __v_324; let __v_326: G = __v_322 + __v_325; let __v_327: G = __v_276 + __v_326; if (__v_285 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_291 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_291.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } if (__v_297 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_297.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } if (__v_303 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_303.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } if (__v_309 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_315 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_315.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } if (__v_321 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_321.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } if (__v_327 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_327.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_246]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_328: G = __r_arr[0]; let __v_329: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_329, __v_328]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, &__args[..])?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_330: G = __r_arr[0]; let __v_331: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_331.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_332: G = __loaded[0]; let __v_333: G = __loaded[1]; let __v_334: G = __loaded[2]; if (__v_332 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_332.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_333 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_333.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_334 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_334.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_335: G = __r_arr[0]; let __v_336: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_336, __v_335]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_337: G = __r_arr[0]; let __v_338: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_338]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_339: G = __r_arr[0]; let __v_340: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_340, __v_339]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_341: G = __r_arr[0]; let __v_342: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_342]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_343: G = __r_arr[0]; let __v_344: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_344, __v_343]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_345: G = __r_arr[0]; let __v_346: G = __r_arr[1]; let __v_347: G = __v_17 + __v_18; if (__v_346 != __v_347) { return Err(ExecError::AssertEqMismatch { lhs: __v_346.as_canonical_u64(), rhs: __v_347.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_142, __v_152, __v_162, __v_172, __v_182, __v_192, __v_202, __v_239, __v_230, __v_233, __v_234, __v_236, __v_337, __v_341, __v_345]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, &__args[..])?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_348: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_348, __v_330]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, &__args[..])?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_349: G = __r_arr[0]; if (__v_349 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_349.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_19 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_238] = []; record.function_queries[238].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; 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], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_239] = [__v_4]; record.function_queries[239].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_239(inp: [G; IN_239], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_239] = [__v_4]; record.function_queries[239].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_240: usize = 1; const IN_240: usize = 1; const OUT_240: usize = 1; -fn aiur_fn_240(inp: [G; IN_240], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; match __v_1.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_240] = [__v_27]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_27 + __v_28); let __ret: [G; OUT_240] = [__v_29]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_240(inp: [G; IN_240], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; match __v_1.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_240] = [__v_27]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = __v_27 + __v_28; let __ret: [G; OUT_240] = [__v_29]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_241: usize = 1; const IN_241: usize = 1; const OUT_241: usize = 1; -fn aiur_fn_241(inp: [G; IN_241], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_241] = [__v_4]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; 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_241] = [__v_6]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_241(inp: [G; IN_241], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_241] = [__v_4]; record.function_queries[241].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; 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_241] = [__v_6]; record.function_queries[241].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_242: usize = 1; const IN_242: usize = 1; const OUT_242: usize = 1; -fn aiur_fn_242(inp: [G; IN_242], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_242] = [__v_5]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; 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_242] = [__v_7]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_242(inp: [G; IN_242], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_242] = [__v_5]; record.function_queries[242].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; 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_242] = [__v_7]; record.function_queries[242].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_243: usize = 2; const IN_243: usize = 2; const OUT_243: usize = 1; -fn aiur_fn_243(inp: [G; IN_243], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_243] = [__v_1]; record.function_queries[243].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_243] = [__v_7]; record.function_queries[243].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_243(inp: [G; IN_243], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_243] = [__v_1]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_243] = [__v_7]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_244: usize = 1; const IN_244: usize = 1; const OUT_244: usize = 1; -fn aiur_fn_244(inp: [G; IN_244], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_244] = [__v_7]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; 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_244] = [__v_9]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_244(inp: [G; IN_244], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_244] = [__v_7]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; 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_244] = [__v_9]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_245: usize = 1; const IN_245: usize = 1; const OUT_245: usize = 1; -fn aiur_fn_245(inp: [G; IN_245], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].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]; match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_8]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, (&__args[..]))?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { (*(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245])) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; 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_245] = [__v_10]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_245(inp: [G; IN_245], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].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]; match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_8]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, &__args[..])?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; 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_245] = [__v_10]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_246: usize = 1; const IN_246: usize = 1; const OUT_246: usize = 1; -fn aiur_fn_246(inp: [G; IN_246], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_246] = [__v_11]; record.function_queries[246].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; 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_246] = [__v_13]; record.function_queries[246].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_246(inp: [G; IN_246], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_246] = [__v_11]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; 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_246] = [__v_13]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_247: usize = 1; const IN_247: usize = 1; const OUT_247: usize = 1; -fn aiur_fn_247(inp: [G; IN_247], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; match __v_1.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_12]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_12 + __v_13); let __ret: [G; OUT_247] = [__v_14]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_247(inp: [G; IN_247], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; match __v_1.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_12]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = __v_12 + __v_13; let __ret: [G; OUT_247] = [__v_14]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_248: usize = 2; const IN_248: usize = 2; const OUT_248: usize = 4; -fn aiur_fn_248(inp: [G; IN_248], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, (&__args[..]))?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { (*(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255])) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_248] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_248(inp: [G; IN_248], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, &__args[..])?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_248] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_249: usize = 1; const IN_249: usize = 1; const OUT_249: usize = 1; -fn aiur_fn_249(inp: [G; IN_249], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_249] = [__v_4]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_4]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_249(inp: [G; IN_249], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_249] = [__v_4]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_4]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_250: usize = 2; const IN_250: usize = 2; const OUT_250: usize = 2; -fn aiur_fn_250(inp: [G; IN_250], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, (&__args[..]))?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { (*(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254])) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_250] = [__v_4, __v_5]; record.function_queries[250].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_250(inp: [G; IN_250], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, &__args[..])?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_250] = [__v_4, __v_5]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_251: usize = 2; const IN_251: usize = 2; const OUT_251: usize = 1; -fn aiur_fn_251(inp: [G; IN_251], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_251] = [__v_1]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_14]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_251(inp: [G; IN_251], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_251] = [__v_1]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, &__args[..])?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; 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_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_14]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_252: usize = 1; const IN_252: usize = 1; const OUT_252: usize = 1; -fn aiur_fn_252(inp: [G; IN_252], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_252] = [__v_6]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, (&__args[..]))?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { (*(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252])) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; 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_252] = [__v_8]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_252(inp: [G; IN_252], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_252] = [__v_6]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, &__args[..])?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; 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_252] = [__v_8]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_253: usize = 2; const IN_253: usize = 2; const OUT_253: usize = 1; -fn aiur_fn_253(inp: [G; IN_253], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_253] = [__v_0]; record.function_queries[253].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_253] = [__v_7]; record.function_queries[253].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_253(inp: [G; IN_253], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_253] = [__v_0]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = __v_1 - __v_2; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); 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_253] = [__v_7]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_254: usize = 2; const IN_254: usize = 2; const OUT_254: usize = 1; -fn aiur_fn_254(inp: [G; IN_254], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_0]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, (&__args[..]))?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { (*(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254])) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_8]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_254(inp: [G; IN_254], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_0]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = __v_1 - __v_2; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, &__args[..])?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_8]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_255: usize = 2; const IN_255: usize = 2; const OUT_255: usize = 1; -fn aiur_fn_255(inp: [G; IN_255], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_0]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, (&__args[..]))?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { (*(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255])) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_10]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_255(inp: [G; IN_255], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_0]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = __v_1 - __v_2; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, &__args[..])?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_10]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } pub(crate) fn execute_generated(fun_idx: usize, args: &[G], record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result, ExecError> { if (record.memory_queries.get_index(0).map(|(size, _)| (*size)) != Some(3)) { return Err(ExecError::InvalidMemorySize(3)); } if (record.memory_queries.get_index(1).map(|(size, _)| (*size)) != Some(4)) { return Err(ExecError::InvalidMemorySize(4)); } if (record.memory_queries.get_index(2).map(|(size, _)| (*size)) != Some(5)) { return Err(ExecError::InvalidMemorySize(5)); } if (record.memory_queries.get_index(3).map(|(size, _)| (*size)) != Some(6)) { return Err(ExecError::InvalidMemorySize(6)); } if (record.memory_queries.get_index(4).map(|(size, _)| (*size)) != Some(7)) { return Err(ExecError::InvalidMemorySize(7)); } if (record.memory_queries.get_index(5).map(|(size, _)| (*size)) != Some(8)) { return Err(ExecError::InvalidMemorySize(8)); } if (record.memory_queries.get_index(6).map(|(size, _)| (*size)) != Some(10)) { return Err(ExecError::InvalidMemorySize(10)); } if (record.memory_queries.get_index(7).map(|(size, _)| (*size)) != Some(11)) { return Err(ExecError::InvalidMemorySize(11)); } if (record.memory_queries.get_index(8).map(|(size, _)| (*size)) != Some(26)) { return Err(ExecError::InvalidMemorySize(26)); } if (record.memory_queries.get_index(9).map(|(size, _)| (*size)) != Some(32)) { return Err(ExecError::InvalidMemorySize(32)); } if (record.memory_queries.get_index(10).map(|(size, _)| (*size)) != Some(34)) { return Err(ExecError::InvalidMemorySize(34)); } let __input_hash = aiur::querymap::hash_g_slice(args); match (fun_idx as u64) { 0u64 => { let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_0::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 1u64 => { let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_1::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 2u64 => { let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_2::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 3u64 => { let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_3::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 4u64 => { let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_4::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 5u64 => { let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_5::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 6u64 => { let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_6::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 7u64 => { let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_7::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 8u64 => { let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_8::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 9u64 => { let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_9::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 10u64 => { let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_10::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 11u64 => { let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_11::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 12u64 => { let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_12::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 13u64 => { let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_13::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 14u64 => { let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_14::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 15u64 => { let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_15::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 16u64 => { let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_16::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 17u64 => { let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_17::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 18u64 => { let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_18::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 19u64 => { let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_19::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 20u64 => { let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_20::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 21u64 => { let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_21::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 22u64 => { let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_22::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 23u64 => { let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_23::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 24u64 => { let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_24::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 25u64 => { let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_25::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 26u64 => { let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_26::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 27u64 => { let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_27::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 28u64 => { let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_28::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 29u64 => { let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_29::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 30u64 => { let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_30::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 31u64 => { let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_31::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 32u64 => { let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_32::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 33u64 => { let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_33::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 34u64 => { let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_34::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 35u64 => { let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_35::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 36u64 => { let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_36::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 37u64 => { let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_37::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 38u64 => { let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_38::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 39u64 => { let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_39::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 40u64 => { let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_40::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 41u64 => { let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_41::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 42u64 => { let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_42::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 43u64 => { let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_43::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 44u64 => { let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_44::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 45u64 => { let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_45::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 46u64 => { let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_46::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 47u64 => { let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_47::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 48u64 => { let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_48::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 49u64 => { let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_49::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 50u64 => { let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_50::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 51u64 => { let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_51::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 52u64 => { let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_52::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 53u64 => { let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_53::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 54u64 => { let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_54::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 55u64 => { let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_55::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 56u64 => { let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_56::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 57u64 => { let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_57::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 58u64 => { let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_58::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 59u64 => { let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_59::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 60u64 => { let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_60::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 61u64 => { let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_61::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 62u64 => { let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_62::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 63u64 => { let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_63::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 64u64 => { let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_64::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 65u64 => { let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_65::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 66u64 => { let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_66::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 67u64 => { let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_67::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 68u64 => { let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_68::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 69u64 => { let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_69::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 70u64 => { let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_70::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 71u64 => { let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_71::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 72u64 => { let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_72::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 73u64 => { let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_73::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 74u64 => { let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_74::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 75u64 => { let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_75::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 76u64 => { let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_76::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 77u64 => { let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_77::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 78u64 => { let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_78::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 79u64 => { let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_79::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 80u64 => { let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_80::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 81u64 => { let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_81::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 82u64 => { let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_82::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 83u64 => { let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_83::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 84u64 => { let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_84::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 85u64 => { let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_85::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 86u64 => { let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_86::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 87u64 => { let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_87::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 88u64 => { let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_88::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 89u64 => { let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_89::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 90u64 => { let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_90::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 91u64 => { let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_91::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 92u64 => { let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_92::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 93u64 => { let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_93::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 94u64 => { let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_94::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 95u64 => { let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_95::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 96u64 => { let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_96::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 97u64 => { let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_97::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 98u64 => { let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_98::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 99u64 => { let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_99::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 100u64 => { let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_100::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 101u64 => { let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_101::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 102u64 => { let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_102::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 103u64 => { let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_103::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 104u64 => { let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_104::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 105u64 => { let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_105::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 106u64 => { let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_106::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 107u64 => { let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_107::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 108u64 => { let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_108::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 109u64 => { let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_109::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 110u64 => { let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_110::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 111u64 => { let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_111::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 112u64 => { let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_112::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 113u64 => { let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_113::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 114u64 => { let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_114::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 115u64 => { let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_115::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 116u64 => { let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_116::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 117u64 => { let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_117::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 118u64 => { let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_118::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 119u64 => { let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_119::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 120u64 => { let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_120::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 121u64 => { let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_121::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 122u64 => { let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_122::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 123u64 => { let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_123::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 124u64 => { let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_124::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 125u64 => { let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_125::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 126u64 => { let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_126::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 127u64 => { let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_127::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 128u64 => { let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_128::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 129u64 => { let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_129::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 130u64 => { let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_130::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 131u64 => { let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_131::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 132u64 => { let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_132::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 133u64 => { let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_133::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 134u64 => { let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_134::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 135u64 => { let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_135::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 136u64 => { let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_136::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 137u64 => { let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_137::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 138u64 => { let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_138::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 139u64 => { let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_139::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 140u64 => { let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_140::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 141u64 => { let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_141::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 142u64 => { let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_142::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 143u64 => { let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_143::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 144u64 => { let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_144::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 145u64 => { let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_145::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 146u64 => { let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_146::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 147u64 => { let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_147::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 148u64 => { let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_148::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 149u64 => { let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_149::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 150u64 => { let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_150::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 151u64 => { let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_151::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 152u64 => { let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_152::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 153u64 => { let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_153::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 154u64 => { let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_154::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 155u64 => { let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_155::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 156u64 => { let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_156::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 157u64 => { let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_157::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 158u64 => { let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_158::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 159u64 => { let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_159::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 160u64 => { let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_160::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 161u64 => { let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_161::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 162u64 => { let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_162::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 163u64 => { let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_163::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 164u64 => { let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_164::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 165u64 => { let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_165::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 166u64 => { let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_166::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 167u64 => { let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_167::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 168u64 => { let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_168::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 169u64 => { let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_169::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 170u64 => { let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_170::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 171u64 => { let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_171::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 172u64 => { let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_172::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 173u64 => { let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_173::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 174u64 => { let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_174::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 175u64 => { let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_175::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 176u64 => { let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_176::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 177u64 => { let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_177::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 178u64 => { let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_178::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 179u64 => { let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_179::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 180u64 => { let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_180::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 181u64 => { let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_181::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 182u64 => { let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_182::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 183u64 => { let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_183::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 184u64 => { let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_184::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 185u64 => { let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_185::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 186u64 => { let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_186::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 187u64 => { let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_187::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 188u64 => { let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_188::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 189u64 => { let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_189::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 190u64 => { let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_190::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 191u64 => { let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_191::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 192u64 => { let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_192::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 193u64 => { let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_193::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 194u64 => { let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_194::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 195u64 => { let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_195::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 196u64 => { let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_196::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 197u64 => { let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_197::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 198u64 => { let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_198::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 199u64 => { let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_199::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 200u64 => { let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_200::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 201u64 => { let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_201::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 202u64 => { let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_202::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 203u64 => { let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_203::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 204u64 => { let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_204::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 205u64 => { let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_205::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 206u64 => { let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_206::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 207u64 => { let __inp: [G; IN_207] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_207::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 208u64 => { let __inp: [G; IN_208] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_208::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 209u64 => { let __inp: [G; IN_209] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_209::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 210u64 => { let __inp: [G; IN_210] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_210::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 211u64 => { let __inp: [G; IN_211] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_211::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 212u64 => { let __inp: [G; IN_212] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_212::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 213u64 => { let __inp: [G; IN_213] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_213::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 214u64 => { let __inp: [G; IN_214] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_214::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 215u64 => { let __inp: [G; IN_215] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_215::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 216u64 => { let __inp: [G; IN_216] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_216::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 217u64 => { let __inp: [G; IN_217] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_217::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 218u64 => { let __inp: [G; IN_218] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_218::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 219u64 => { let __inp: [G; IN_219] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_219::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 220u64 => { let __inp: [G; IN_220] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_220::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 221u64 => { let __inp: [G; IN_221] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_221::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 222u64 => { let __inp: [G; IN_222] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_222::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 223u64 => { let __inp: [G; IN_223] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_223::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 224u64 => { let __inp: [G; IN_224] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_224::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 225u64 => { let __inp: [G; IN_225] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_225::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 226u64 => { let __inp: [G; IN_226] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_226::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 227u64 => { let __inp: [G; IN_227] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_227::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 228u64 => { let __inp: [G; IN_228] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_228::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 229u64 => { let __inp: [G; IN_229] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_229::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 230u64 => { let __inp: [G; IN_230] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_230::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 231u64 => { let __inp: [G; IN_231] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_231::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 232u64 => { let __inp: [G; IN_232] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_232::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 233u64 => { let __inp: [G; IN_233] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_233::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 234u64 => { let __inp: [G; IN_234] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_234::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 235u64 => { let __inp: [G; IN_235] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_235::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 236u64 => { let __inp: [G; IN_236] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_236::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 237u64 => { let __inp: [G; IN_237] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_237::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 238u64 => { let __inp: [G; IN_238] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_238::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 239u64 => { let __inp: [G; IN_239] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_239::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 240u64 => { let __inp: [G; IN_240] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_240::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 241u64 => { let __inp: [G; IN_241] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_241::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 242u64 => { let __inp: [G; IN_242] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_242::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 243u64 => { let __inp: [G; IN_243] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_243::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 244u64 => { let __inp: [G; IN_244] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_244::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 245u64 => { let __inp: [G; IN_245] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_245::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 246u64 => { let __inp: [G; IN_246] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_246::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 247u64 => { let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_247::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 248u64 => { let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_248::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 249u64 => { let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_249::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 250u64 => { let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_250::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 251u64 => { let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_251::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 252u64 => { let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_252::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 253u64 => { let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_253::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 254u64 => { let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_254::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 255u64 => { let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_255::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } diff --git a/lakefile.lean b/lakefile.lean index 0702ad935..0dd324527 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -168,6 +168,13 @@ lean_exe «arena-exclude» where root := `Tests.Ix.Kernel.ArenaExclude supportInterpreter := true +/-- Regenerates, or with `--check` verifies, the trace-codegen test fixtures: +the Rust writers, CUDA units and manifest the `aiur` parity tests compile +against. -/ +lean_exe «trace-fixtures» where + root := `Tests.Aiur.TraceFixtures + supportInterpreter := true + /-- Focused source-contract checks, including fresh-module registration export. -/ lean_exe «source-contract-tests» where root := `Tests.SourceContractMain From 6529c2353b54c2781c389ab9846d1078c6771c70 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Thu, 1 Oct 2026 09:47:43 -0400 Subject: [PATCH 4/9] docs: proving on GPUs, in one document How the GPU build is layered and built, the four-command pipeline for a whole environment on several devices, how the lanes scheduler governs memory, what the generated traces are and how to regenerate and test them, every knob a run or a measurement needs, and the benchmark procedure with the Mathlib and FLT results it produced. The design discussions, dated run reports and planning documents it condenses stay on `sb/aiur-gpu-lanes-sp1-compress`, which the document and the handoff point to. --- README.md | 9 +- docs/aiur-gpu-proving.md | 275 ++++++++++++++++++++++++++++++ docs/aiur-trace-sharding.md | 5 + docs/trace-sharding-pr-handoff.md | 70 +++----- 4 files changed, 307 insertions(+), 52 deletions(-) create mode 100644 docs/aiur-gpu-proving.md diff --git a/README.md b/README.md index 8cac0b8ce..fe22e0920 100644 --- a/README.md +++ b/README.md @@ -196,9 +196,12 @@ Rust consumers can instead enable the `cuda` feature on `aiur` or `ix-ffi`. The backend requires an NVIDIA GPU and a CUDA toolkit with `nvcc`; build and architecture controls are documented in the multi-stark repository. It keeps the Goldilocks/BLAKE3 protocol and proof format unchanged, and GPU proofs remain -verifiable by the CPU implementation. Dated hardware measurements belong in -[BENCHMARKS.md](BENCHMARKS.md) and [docs/benchmarking.md](docs/benchmarking.md), -not this stable overview. +verifiable by the CPU implementation. Proving a whole environment across +several GPUs (`ix prove --lanes`), generating traces on the device, and +benchmarking such runs are covered in +[docs/aiur-gpu-proving.md](docs/aiur-gpu-proving.md). Dated hardware +measurements belong in [BENCHMARKS.md](BENCHMARKS.md) and +[docs/benchmarking.md](docs/benchmarking.md), not this stable overview. ## Usage diff --git a/docs/aiur-gpu-proving.md b/docs/aiur-gpu-proving.md new file mode 100644 index 000000000..f901802ad --- /dev/null +++ b/docs/aiur-gpu-proving.md @@ -0,0 +1,275 @@ +# Proving on GPUs: lanes, generated traces, and how to benchmark them + +Everything in this document builds on prover-level trace sharding +([aiur-trace-sharding.md](aiur-trace-sharding.md)): one execution of a +claim is proven as a batch of trace shards that each fit a device, and the +Stage 2 aggregation tree joins the claims' proofs into one root. This +document covers what the GPU build adds on top: proving several claims at +once on several devices from one process, generating the main traces on +the device instead of the host, and the knobs and measurements a benchmark +of either needs. + +## 1. What the GPU build is + +Three layers, each a Cargo feature over the previous one: + +| Feature | Lake switch | What it compiles | +|---|---|---| +| `cuda` | `IX_CUDA=1` | multi-stark's CUDA backend: device LDEs, Merkle trees, lookup and quotient kernels, with sppark for every NTT. Proofs are the same Goldilocks/BLAKE3 protocol the CPU verifies. | +| `cuda-trace-codegen` | `IX_CUDA_TRACE_CODEGEN=1` | The CUDA row writers generated from the compiled bytecode (§4), their Rust seed packers, and the registry the trace runtime binds against. Implies `cuda`. | + +The lanes scheduler (§3) needs only `cuda`; generated traces are an +optional provider inside it. On the host the ordinary `ix` binary runs +everything else unchanged. + +Build on a GPU host: + +```sh +IX_CUDA_TRACE_CODEGEN=1 MULTI_STARK_CUDA_ARCHS=120 CFLAGS=-std=gnu17 lake build ix +``` + +`MULTI_STARK_CUDA_ARCHS` names the SM architecture (`120` is Blackwell, +`80` the CI container's Ampere). `CFLAGS=-std=gnu17` is required with +glibc 2.43 headers: in C23 mode mimalloc's `strtol` becomes +`__isoc23_strtol`, which the sysroot of Lean's bundled `clang`/`ld.lld` +does not provide, and the final link fails on `libix_ffi_net.a`. If `nvcc` +is not on `PATH`, set `NVCC` or `CUDA_HOME`. + +A binary linked by the Nix Rust toolchain runs on Nix glibc, whose loader +never searches `/usr/lib/x86_64-linux-gnu`; the statically linked CUDA +runtime then fails to open `libcuda.so.1` and reports "CUDA driver version +is insufficient" (error 35). Give it the driver library and the matching +`libstdc++`, nothing else, so libc is not mixed: + +```sh +export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libcuda.so.1 +export LD_LIBRARY_PATH="$(dirname "$(gcc -print-file-name=libstdc++.so.6)"):$LD_LIBRARY_PATH" +``` + +Binaries built with the host's own toolchain need neither. + +## 2. The pipeline, end to end + +With `mathlib.ixe` compiled and the GPU binary built, a whole environment +proves in four commands. The run directory holds the inputs and the +caches; the whole process goes under one cgroup cap, since one process now +holds every worker and the record pool is the thing that grows. + +```sh +# 0. Partition. The CUDA build seeds the shard count from the per-worker +# record share (--max-ram, --exec-jobs and the cell budget below). +ix shard mathlib.ixe --max-ram 230 --exec-jobs 3 --out mathlib.ixes + +# 1 + 2. Stage 1 and Stage 2 on four devices. Every claim's proof is +# persisted as it lands; joins run as soon as their children exist; +# the root is wrapped until it is a single trace shard, verified, +# and its address printed on stdout. +export AIUR_TRACE_ONLY_LOOKUPS=1 AIUR_MAX_PIECE_LOG_HEIGHT=24 +export AIUR_TRACE_SHARD_MAX_CELLS=1500000000 +export AIUR_GPU_TRACE=generated AIUR_LANES_CACHE_DIR=$PWD/cache +systemd-run --user --scope -q -p MemoryMax=920G -- \ + ix prove --ixe mathlib.ixe --ixes mathlib.ixes --trace-shards \ + --lanes 4 --exec-jobs 3 --max-ram 230 --out-ixes mathlib-proven.ixes \ + > lanes.out 2> lanes.err + +# 3. Verify the root against the partition that was actually proven. +ix verify --aggregate --structural-above 0 --ixe mathlib.ixe \ + --ixes mathlib-proven.ixes "$(tail -1 lanes.out)" +``` + +Rerunning the same command resumes: completed claim proofs and join +subtrees are reused from the cache directory, and a bisected partition is +picked up from its checkpoint. `--out-ixes` matters because bisection +changes the partition, and `ix verify --ixes` must see the one the proofs +belong to. + +The same two stages can still be driven by hand, one device per process, +with `ix prove --trace-shards --shards ` for a lane's claims and +`ix aggregate --trace-shards --subtree ` for its subtree; the lanes +scheduler is the one-process equivalent and is what the measurements in +§6 used. + +## 3. Lanes: one resident prover per device + +`ix prove --lanes N` builds an `AiurSystem` pair per device from the two +compiled systems (nothing is copied across the FFI; the verifying keys do +not depend on the device, and every cache key and claim binding derives +from them) and runs one scheduler over them: + +- **One execution pool.** Claims and ready joins execute on the host + through one bounded queue, joins first, `--exec-jobs` executions at a + time per lane. A prepared record goes to whichever device is free, so no + packing is decided ahead of time. +- **Record reservations.** Each execution reserves its record's bytes from + a pool sized by `--max-ram` per lane; the reservation follows the record + through both proving rounds and is released when the proof lands. Under + pressure, executions wait for capacity; if waiters block each other, the + youngest is cancelled so the selected one can finish. +- **The record ceiling.** An environment claim whose record would exceed + 128 GiB (`AIUR_RECORD_MAX_BYTES` overrides it) is stopped, its leaf + bisected into two claims, and the partition checkpointed; the halves are + proven and joined like any other leaves. The ceiling is a guard against a + single claim starving the pool, not a performance setting. +- **Stage 2 inside the run.** The aggregation plan is cut into subtrees + from the root while a frontier node holds more leaves than the target; + a subtree is proven as one task once its leaves exist, upper joins once + both children are published, and the root is wrapped and verified at + the end. + +Memory is governed by three numbers and nothing else: `--max-ram` (the +record pool per lane), `--exec-jobs` (records in flight per lane, so the +cold wave and the speculative execution concurrency), and the cgroup cap +as the backstop. On a 4-GPU, 1 TiB host, `--max-ram 230 --exec-jobs 3` +keeps Mathlib's largest records (about 45 GiB) inside one lane's share and +the process peak under 750 GiB; `--exec-jobs 4` is 5% faster at the cost +of the pool running at 99%. + +## 4. Generated traces + +With `AIUR_GPU_TRACE=generated`, the main trace of every constrained +function is written on the device from a compact seed instead of being +built on the host and uploaded. The compiler derives, per function, a +**trace plan** from the compiled bytecode: which SSA values each row +needs, the seed words an execution records for it, and the column spans +it writes. From the plan it emits matching Rust seed packers and CUDA row +writers, and a registry with the program's fingerprint; at proving time +the runtime binds the registry after checking the fingerprint, and any +circuit the registry does not cover falls back to the CPU builder. + +Seeds carry a **typed schema**: one width per word (`u8`, `u16`, `u32` or +full) derived from exclusive value bounds, so a byte-table operand costs a +byte on the wire. Round-two seeds stay resident on the device (bounded by +`AIUR_GPU_SEED_CACHE_BYTES`, 16 GiB by default) so regeneration does not +re-upload them; memory-table rows stay on the host unless +`AIUR_GPU_TRACE_MEMORY=1`, because a memory seed is the row minus one +column and generating them bought nothing on Init. + +The generated units are checked in and regenerated like the executors: + +```sh +lake exe ix codegen --trace-bundle # regenerate the three programs' units +lake exe ix codegen --trace-bundle --check # CI: fail on a stale unit +lake exe ix codegen --trace-report --target ixvm # the plan inventory as JSON +lake exe IxTests aiur-trace-plan # planner fixtures +cargo test -p aiur trace_codegen # Rust parity, no GPU needed +``` + +The fixtures the Rust parity tests compile against are produced by the +same generator from two test programs: + +```sh +lake exe trace-fixtures # regenerate crates/aiur/src/trace_codegen/tests/* and cuda/generated/* +lake exe trace-fixtures --check # fail on a stale fixture +``` + +The GPU-side parity tests and the two-round generated proof need a device: + +```sh +NVCC=/usr/local/cuda-13.3/bin/nvcc MULTI_STARK_CUDA_ARCHS=120 \ + AIUR_TEST_GPU_DEVICES=0,1,2,3 \ + cargo test -p aiur --release --features cuda-trace-codegen +``` + +## 5. Knobs + +The ones a run needs, then the ones a measurement might. + +| Variable or flag | Meaning | +|---|---| +| `AIUR_TRACE_ONLY_LOOKUPS=1` | The lookup witness carries dimensions only; the device derives multiplicities and arguments from the committed trace. Required by every GPU trace provider and by trace sharding on the device. | +| `AIUR_TRACE_SHARD_MAX_CELLS` | Committed cells per trace shard the planner cuts to. `1500000000` fits a 96 GB device at `log_blowup = 2` with headroom; the sizing rule is §7.1 of the trace-sharding document. | +| `AIUR_MAX_PIECE_LOG_HEIGHT=24` | Caps a piece's trace height, so a tall circuit is cut shorter than the room alone requires, at one activation per extra piece. | +| `AIUR_GPU_TRACE=cpu\|generated` | Main-trace provider (§4); `cpu` is the reference builder and the default. | +| `AIUR_RECORD_MAX_BYTES` | The record ceiling (§3), default 128 GiB. Size it from the pool: 256 GiB at a 731 GiB pool held FLT's 174 GiB leaf without waits. | +| `AIUR_LANES_CACHE_DIR` | Where completed claim proofs, join subtrees and the partition checkpoint live between runs. | +| `--retention retain\|regenerate\|auto` | What a batch keeps between its two rounds. Every real GPU plan runs `regenerate`: round two rebuilds each shard from its seeds, which the resident seed cache makes cheap. | +| `MULTI_STARK_CUDA_MIN_FREE_BYTES` | Device headroom the backend keeps by spilling LDEs to the host; default a quarter of the card. | +| `MULTI_STARK_CUDA_MEMORY_LOG=1` | Logs stage-1 placement and per-lookup-job budget and free bytes to stderr. | +| `MULTI_STARK_CUDA_TRACE_FORCE_SPILL=1`, `MULTI_STARK_CUDA_LOOKUP_TRACE_TILE_ROWS=3` | Validation only: spill every LDE and regenerate from tiny tiles, to exercise the recovery path. | +| `AIUR_METRICS=`, `AIUR_METRICS_RUN_ID` | Lightweight per-piece and per-execution summaries (§6). | +| `AIUR_PROFILE=` | Timestamped span events, per-circuit witness time included. Heavier than metrics; not for timing runs. | +| `--texray` | Per-phase wall and RSS lines on stderr, as on the CPU. | + +## 6. Benchmarking a multi-GPU run + +The unit of measurement is one complete `.ixe`/`.ixes` pair under one +command, recorded with its identities. The script that produced the +measurements below does only this: write the provenance, sample the +devices, run the one command under the cap, and keep the exit status. + +```sh +#!/bin/bash +# run-lanes4.sh